{"version":3,"file":"static/js/3579.e97433aa.js","mappings":"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","sources":["../node_modules/plotly.js/src/plots/animation_attributes.js","../node_modules/plotly.js/src/plots/array_container_defaults.js","../node_modules/plotly.js/src/plots/attributes.js","../node_modules/plotly.js/src/plots/cartesian/align_period.js","../node_modules/plotly.js/src/plots/cartesian/attributes.js","../node_modules/plotly.js/src/plots/cartesian/autorange.js","../node_modules/plotly.js/src/plots/cartesian/autorange_options_defaults.js","../node_modules/plotly.js/src/plots/cartesian/axes.js","../node_modules/plotly.js/src/plots/cartesian/axis_autotype.js","../node_modules/plotly.js/src/plots/cartesian/axis_defaults.js","../node_modules/plotly.js/src/plots/cartesian/axis_format_attributes.js","../node_modules/plotly.js/src/plots/cartesian/axis_ids.js","../node_modules/plotly.js/src/plots/cartesian/category_order_defaults.js","../node_modules/plotly.js/src/plots/cartesian/clean_ticks.js","../node_modules/plotly.js/src/plots/cartesian/constants.js","../node_modules/plotly.js/src/plots/cartesian/constraints.js","../node_modules/plotly.js/src/plots/cartesian/dragbox.js","../node_modules/plotly.js/src/plots/cartesian/graph_interact.js","../node_modules/plotly.js/src/plots/cartesian/include_components.js","../node_modules/plotly.js/src/plots/cartesian/index.js","../node_modules/plotly.js/src/plots/cartesian/layout_attributes.js","../node_modules/plotly.js/src/plots/cartesian/layout_defaults.js","../node_modules/plotly.js/src/plots/cartesian/line_grid_defaults.js","../node_modules/plotly.js/src/plots/cartesian/position_defaults.js","../node_modules/plotly.js/src/plots/cartesian/prefix_suffix_defaults.js","../node_modules/plotly.js/src/plots/cartesian/range_defaults.js","../node_modules/plotly.js/src/plots/cartesian/scale_zoom.js","../node_modules/plotly.js/src/plots/cartesian/set_convert.js","../node_modules/plotly.js/src/plots/cartesian/show_dflt.js","../node_modules/plotly.js/src/plots/cartesian/tick_label_defaults.js","../node_modules/plotly.js/src/plots/cartesian/tick_mark_defaults.js","../node_modules/plotly.js/src/plots/cartesian/tick_value_defaults.js","../node_modules/plotly.js/src/plots/cartesian/transition_axes.js","../node_modules/plotly.js/src/plots/cartesian/type_defaults.js","../node_modules/plotly.js/src/plots/command.js","../node_modules/plotly.js/src/plots/domain.js","../node_modules/plotly.js/src/plots/font_attributes.js","../node_modules/plotly.js/src/plots/frame_attributes.js"],"sourcesContent":["'use strict';\n\nmodule.exports = {\n    mode: {\n        valType: 'enumerated',\n        dflt: 'afterall',\n        values: ['immediate', 'next', 'afterall'],\n        description: [\n            'Describes how a new animate call interacts with currently-running',\n            'animations. If `immediate`, current animations are interrupted and',\n            'the new animation is started. If `next`, the current frame is allowed',\n            'to complete, after which the new animation is started. If `afterall`',\n            'all existing frames are animated to completion before the new animation',\n            'is started.'\n        ].join(' ')\n    },\n    direction: {\n        valType: 'enumerated',\n        values: ['forward', 'reverse'],\n        dflt: 'forward',\n        description: [\n            'The direction in which to play the frames triggered by the animation call'\n        ].join(' ')\n    },\n    fromcurrent: {\n        valType: 'boolean',\n        dflt: false,\n        description: [\n            'Play frames starting at the current frame instead of the beginning.'\n        ].join(' ')\n    },\n    frame: {\n        duration: {\n            valType: 'number',\n            min: 0,\n            dflt: 500,\n            description: [\n                'The duration in milliseconds of each frame. If greater than the frame',\n                'duration, it will be limited to the frame duration.'\n            ].join(' ')\n        },\n        redraw: {\n            valType: 'boolean',\n            dflt: true,\n            description: [\n                'Redraw the plot at completion of the transition. This is desirable',\n                'for transitions that include properties that cannot be transitioned,',\n                'but may significantly slow down updates that do not require a full',\n                'redraw of the plot'\n            ].join(' ')\n        },\n    },\n    transition: {\n        duration: {\n            valType: 'number',\n            min: 0,\n            dflt: 500,\n            editType: 'none',\n            description: [\n                'The duration of the transition, in milliseconds. If equal to zero,',\n                'updates are synchronous.'\n            ].join(' ')\n        },\n        easing: {\n            valType: 'enumerated',\n            dflt: 'cubic-in-out',\n            values: [\n                'linear',\n                'quad',\n                'cubic',\n                'sin',\n                'exp',\n                'circle',\n                'elastic',\n                'back',\n                'bounce',\n                'linear-in',\n                'quad-in',\n                'cubic-in',\n                'sin-in',\n                'exp-in',\n                'circle-in',\n                'elastic-in',\n                'back-in',\n                'bounce-in',\n                'linear-out',\n                'quad-out',\n                'cubic-out',\n                'sin-out',\n                'exp-out',\n                'circle-out',\n                'elastic-out',\n                'back-out',\n                'bounce-out',\n                'linear-in-out',\n                'quad-in-out',\n                'cubic-in-out',\n                'sin-in-out',\n                'exp-in-out',\n                'circle-in-out',\n                'elastic-in-out',\n                'back-in-out',\n                'bounce-in-out'\n            ],\n            editType: 'none',\n            description: 'The easing function used for the transition'\n        },\n        ordering: {\n            valType: 'enumerated',\n            values: ['layout first', 'traces first'],\n            dflt: 'layout first',\n            editType: 'none',\n            description: [\n                'Determines whether the figure\\'s layout or traces smoothly transitions',\n                'during updates that make both traces and layout change.'\n            ].join(' ')\n        }\n    }\n};\n","'use strict';\n\nvar Lib = require('../lib');\nvar Template = require('../plot_api/plot_template');\n\n/** Convenience wrapper for making array container logic DRY and consistent\n *\n * @param {object} parentObjIn\n *  user input object where the container in question is linked\n *  (i.e. either a user trace object or the user layout object)\n *\n * @param {object} parentObjOut\n *  full object where the coerced container will be linked\n *  (i.e. either a full trace object or the full layout object)\n *\n * @param {object} opts\n *  options object:\n *   - name {string}\n *      name of the key linking the container in question\n *   - inclusionAttr {string}\n *      name of the item attribute for inclusion/exclusion. Default is 'visible'.\n *      Since inclusion is true, use eg 'enabled' instead of 'disabled'.\n *   - handleItemDefaults {function}\n *      defaults method to be called on each item in the array container in question\n *\n *      Its arguments are:\n *          - itemIn {object} item in user layout\n *          - itemOut {object} item in full layout\n *          - parentObj {object} (as in closure)\n *          - opts {object} (as in closure)\n * N.B.\n *\n *  - opts is passed to handleItemDefaults so it can also store\n *    links to supplementary data (e.g. fullData for layout components)\n *\n */\nmodule.exports = function handleArrayContainerDefaults(parentObjIn, parentObjOut, opts) {\n    var name = opts.name;\n    var inclusionAttr = opts.inclusionAttr || 'visible';\n\n    var previousContOut = parentObjOut[name];\n\n    var contIn = Lib.isArrayOrTypedArray(parentObjIn[name]) ? parentObjIn[name] : [];\n    var contOut = parentObjOut[name] = [];\n    var templater = Template.arrayTemplater(parentObjOut, name, inclusionAttr);\n    var i, itemOut;\n\n    for(i = 0; i < contIn.length; i++) {\n        var itemIn = contIn[i];\n\n        if(!Lib.isPlainObject(itemIn)) {\n            itemOut = templater.newItem({});\n            itemOut[inclusionAttr] = false;\n        } else {\n            itemOut = templater.newItem(itemIn);\n        }\n\n        itemOut._index = i;\n\n        if(itemOut[inclusionAttr] !== false) {\n            opts.handleItemDefaults(itemIn, itemOut, parentObjOut, opts);\n        }\n\n        contOut.push(itemOut);\n    }\n\n    var defaultItems = templater.defaultItems();\n    for(i = 0; i < defaultItems.length; i++) {\n        itemOut = defaultItems[i];\n        itemOut._index = contOut.length;\n        opts.handleItemDefaults({}, itemOut, parentObjOut, opts, {});\n        contOut.push(itemOut);\n    }\n\n    // in case this array gets its defaults rebuilt independent of the whole layout,\n    // relink the private keys just for this array.\n    if(Lib.isArrayOrTypedArray(previousContOut)) {\n        var len = Math.min(previousContOut.length, contOut.length);\n        for(i = 0; i < len; i++) {\n            Lib.relinkPrivateKeys(contOut[i], previousContOut[i]);\n        }\n    }\n\n    return contOut;\n};\n","'use strict';\n\nvar fontAttrs = require('./font_attributes');\nvar fxAttrs = require('../components/fx/attributes');\n\nmodule.exports = {\n    type: {\n        valType: 'enumerated',\n        values: [],     // listed dynamically\n        dflt: 'scatter',\n        editType: 'calc+clearAxisTypes',\n        _noTemplating: true // we handle this at a higher level\n    },\n    visible: {\n        valType: 'enumerated',\n        values: [true, false, 'legendonly'],\n        dflt: true,\n        editType: 'calc',\n        description: [\n            'Determines whether or not this trace is visible.',\n            'If *legendonly*, the trace is not drawn,',\n            'but can appear as a legend item',\n            '(provided that the legend itself is visible).'\n        ].join(' ')\n    },\n    showlegend: {\n        valType: 'boolean',\n        dflt: true,\n        editType: 'style',\n        description: [\n            'Determines whether or not an item corresponding to this',\n            'trace is shown in the legend.'\n        ].join(' ')\n    },\n    legend: {\n        valType: 'subplotid',\n        dflt: 'legend',\n        editType: 'style',\n\n        description: [\n            'Sets the reference to a legend to show this trace in.',\n            'References to these legends are *legend*, *legend2*, *legend3*, etc.',\n            'Settings for these legends are set in the layout, under',\n            '`layout.legend`, `layout.legend2`, etc.'\n        ].join(' ')\n    },\n    legendgroup: {\n        valType: 'string',\n        dflt: '',\n        editType: 'style',\n        description: [\n            'Sets the legend group for this trace.',\n            'Traces and shapes part of the same legend group hide/show at the same time',\n            'when toggling legend items.'\n        ].join(' ')\n    },\n    legendgrouptitle: {\n        text: {\n            valType: 'string',\n            dflt: '',\n            editType: 'style',\n            description: [\n                'Sets the title of the legend group.'\n            ].join(' ')\n        },\n        font: fontAttrs({\n            editType: 'style',\n            description: [\n                'Sets this legend group\\'s title font.'\n            ].join(' '),\n        }),\n        editType: 'style',\n    },\n    legendrank: {\n        valType: 'number',\n        dflt: 1000,\n        editType: 'style',\n        description: [\n            'Sets the legend rank for this trace.',\n            'Items and groups with smaller ranks are presented on top/left side while',\n            'with *reversed* `legend.traceorder` they are on bottom/right side.',\n            'The default legendrank is 1000,',\n            'so that you can use ranks less than 1000 to place certain items before all unranked items,',\n            'and ranks greater than 1000 to go after all unranked items.',\n            'When having unranked or equal rank items shapes would be displayed after traces',\n            'i.e. according to their order in data and layout.'\n        ].join(' ')\n    },\n    legendwidth: {\n        valType: 'number',\n        min: 0,\n        editType: 'style',\n        description: 'Sets the width (in px or fraction) of the legend for this trace.',\n    },\n    opacity: {\n        valType: 'number',\n        min: 0,\n        max: 1,\n        dflt: 1,\n        editType: 'style',\n        description: 'Sets the opacity of the trace.'\n    },\n    name: {\n        valType: 'string',\n        editType: 'style',\n        description: [\n            'Sets the trace name.',\n            'The trace name appears as the legend item and on hover.'\n        ].join(' ')\n    },\n    uid: {\n        valType: 'string',\n        editType: 'plot',\n        anim: true,\n        description: [\n            'Assign an id to this trace,',\n            'Use this to provide object constancy between traces during animations',\n            'and transitions.'\n        ].join(' ')\n    },\n    ids: {\n        valType: 'data_array',\n        editType: 'calc',\n        anim: true,\n        description: [\n            'Assigns id labels to each datum.',\n            'These ids for object constancy of data points during animation.',\n            'Should be an array of strings, not numbers or any other type.'\n        ].join(' ')\n    },\n    customdata: {\n        valType: 'data_array',\n        editType: 'calc',\n        description: [\n            'Assigns extra data each datum.',\n            'This may be useful when listening to hover, click and selection events.',\n            'Note that, *scatter* traces also appends customdata items in the markers',\n            'DOM elements'\n        ].join(' ')\n    },\n    meta: {\n        valType: 'any',\n        arrayOk: true,\n        editType: 'plot',\n        description: [\n            'Assigns extra meta information associated with this trace',\n            'that can be used in various text attributes.',\n            'Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text`',\n            '`rangeselector`, `updatemenues` and `sliders` `label` text',\n            'all support `meta`.',\n            'To access the trace `meta` values in an attribute in the same trace, simply use',\n            '`%{meta[i]}` where `i` is the index or key of the `meta`',\n            'item in question.',\n            'To access trace `meta` in layout attributes, use',\n            '`%{data[n[.meta[i]}` where `i` is the index or key of the `meta`',\n            'and `n` is the trace index.'\n        ].join(' ')\n    },\n\n    // N.B. these cannot be 'data_array' as they do not have the same length as\n    // other data arrays and arrayOk attributes in general\n    //\n    // Maybe add another valType:\n    // https://github.com/plotly/plotly.js/issues/1894\n    selectedpoints: {\n        valType: 'any',\n        editType: 'calc',\n        description: [\n            'Array containing integer indices of selected points.',\n            'Has an effect only for traces that support selections.',\n            'Note that an empty array means an empty selection where the `unselected`',\n            'are turned on for all points, whereas, any other non-array values means no',\n            'selection all where the `selected` and `unselected` styles have no effect.'\n        ].join(' ')\n    },\n\n    hoverinfo: {\n        valType: 'flaglist',\n        flags: ['x', 'y', 'z', 'text', 'name'],\n        extras: ['all', 'none', 'skip'],\n        arrayOk: true,\n        dflt: 'all',\n        editType: 'none',\n        description: [\n            'Determines which trace information appear on hover.',\n            'If `none` or `skip` are set, no information is displayed upon hovering.',\n            'But, if `none` is set, click and hover events are still fired.'\n        ].join(' ')\n    },\n    hoverlabel: fxAttrs.hoverlabel,\n    stream: {\n        token: {\n            valType: 'string',\n            noBlank: true,\n            strict: true,\n            editType: 'calc',\n            description: [\n                'The stream id number links a data trace on a plot with a stream.',\n                'See https://chart-studio.plotly.com/settings for more details.'\n            ].join(' ')\n        },\n        maxpoints: {\n            valType: 'number',\n            min: 0,\n            max: 10000,\n            dflt: 500,\n            editType: 'calc',\n            description: [\n                'Sets the maximum number of points to keep on the plots from an',\n                'incoming stream.',\n                'If `maxpoints` is set to *50*, only the newest 50 points will',\n                'be displayed on the plot.'\n            ].join(' ')\n        },\n        editType: 'calc'\n    },\n    transforms: {\n        _isLinkedToArray: 'transform',\n        editType: 'calc',\n        description: [\n            'WARNING: All transforms are deprecated and may be removed from the API in next major version.',\n            'An array of operations that manipulate the trace data,',\n            'for example filtering or sorting the data arrays.'\n        ].join(' ')\n    },\n    uirevision: {\n        valType: 'any',\n        editType: 'none',\n        description: [\n            'Controls persistence of some user-driven changes to the trace:',\n            '`constraintrange` in `parcoords` traces, as well as some',\n            '`editable: true` modifications such as `name` and `colorbar.title`.',\n            'Defaults to `layout.uirevision`.',\n            'Note that other user-driven trace attribute changes are controlled',\n            'by `layout` attributes:',\n            '`trace.visible` is controlled by `layout.legend.uirevision`,',\n            '`selectedpoints` is controlled by `layout.selectionrevision`,',\n            'and `colorbar.(x|y)` (accessible with `config: {editable: true}`)',\n            'is controlled by `layout.editrevision`.',\n            'Trace changes are tracked by `uid`, which only falls back on trace',\n            'index if no `uid` is provided. So if your app can add/remove traces',\n            'before the end of the `data` array, such that the same trace has a',\n            'different index, you can still preserve user-driven changes if you',\n            'give each trace a `uid` that stays with it as it moves.'\n        ].join(' ')\n    }\n};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\nvar Lib = require('../../lib');\nvar dateTime2ms = Lib.dateTime2ms;\nvar incrementMonth = Lib.incrementMonth;\nvar constants = require('../../constants/numerical');\nvar ONEAVGMONTH = constants.ONEAVGMONTH;\n\nmodule.exports = function alignPeriod(trace, ax, axLetter, vals) {\n    if(ax.type !== 'date') return {vals: vals};\n\n    var alignment = trace[axLetter + 'periodalignment'];\n    if(!alignment) return {vals: vals};\n\n    var period = trace[axLetter + 'period'];\n    var mPeriod;\n    if(isNumeric(period)) {\n        period = +period;\n        if(period <= 0) return {vals: vals};\n    } else if(typeof period === 'string' && period.charAt(0) === 'M') {\n        var n = +(period.substring(1));\n        if(n > 0 && Math.round(n) === n) {\n            mPeriod = n;\n        } else return {vals: vals};\n    }\n\n    var calendar = ax.calendar;\n\n    var isStart = 'start' === alignment;\n    // var isMiddle = 'middle' === alignment;\n    var isEnd = 'end' === alignment;\n\n    var period0 = trace[axLetter + 'period0'];\n    var base = dateTime2ms(period0, calendar) || 0;\n\n    var newVals = [];\n    var starts = [];\n    var ends = [];\n\n    var len = vals.length;\n    for(var i = 0; i < len; i++) {\n        var v = vals[i];\n\n        var nEstimated, startTime, endTime;\n        if(mPeriod) {\n            // guess at how many periods away from base we are\n            nEstimated = Math.round((v - base) / (mPeriod * ONEAVGMONTH));\n            endTime = incrementMonth(base, mPeriod * nEstimated, calendar);\n\n            // iterate to get the exact bounds before and after v\n            // there may be ways to make this faster, but most of the time\n            // we'll only execute each loop zero or one time.\n            while(endTime > v) {\n                endTime = incrementMonth(endTime, -mPeriod, calendar);\n            }\n            while(endTime <= v) {\n                endTime = incrementMonth(endTime, mPeriod, calendar);\n            }\n\n            // now we know endTime is the boundary immediately after v\n            // so startTime is obtained by incrementing backward one period.\n            startTime = incrementMonth(endTime, -mPeriod, calendar);\n        } else { // case of ms\n            nEstimated = Math.round((v - base) / period);\n            endTime = base + nEstimated * period;\n\n            while(endTime > v) {\n                endTime -= period;\n            }\n            while(endTime <= v) {\n                endTime += period;\n            }\n\n            startTime = endTime - period;\n        }\n\n        newVals[i] = (\n            isStart ? startTime :\n            isEnd ? endTime :\n            (startTime + endTime) / 2\n        );\n\n        starts[i] = startTime;\n        ends[i] = endTime;\n    }\n\n    return {\n        vals: newVals,\n        starts: starts,\n        ends: ends\n    };\n};\n","'use strict';\n\n\nmodule.exports = {\n    xaxis: {\n        valType: 'subplotid',\n        dflt: 'x',\n        editType: 'calc+clearAxisTypes',\n        description: [\n            'Sets a reference between this trace\\'s x coordinates and',\n            'a 2D cartesian x axis.',\n            'If *x* (the default value), the x coordinates refer to',\n            '`layout.xaxis`.',\n            'If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.'\n        ].join(' ')\n    },\n    yaxis: {\n        valType: 'subplotid',\n        dflt: 'y',\n        editType: 'calc+clearAxisTypes',\n        description: [\n            'Sets a reference between this trace\\'s y coordinates and',\n            'a 2D cartesian y axis.',\n            'If *y* (the default value), the y coordinates refer to',\n            '`layout.yaxis`.',\n            'If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.'\n        ].join(' ')\n    }\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar isNumeric = require('fast-isnumeric');\n\nvar Lib = require('../../lib');\nvar FP_SAFE = require('../../constants/numerical').FP_SAFE;\nvar Registry = require('../../registry');\nvar Drawing = require('../../components/drawing');\n\nvar axIds = require('./axis_ids');\nvar getFromId = axIds.getFromId;\nvar isLinked = axIds.isLinked;\n\nmodule.exports = {\n    applyAutorangeOptions: applyAutorangeOptions,\n    getAutoRange: getAutoRange,\n    makePadFn: makePadFn,\n    doAutoRange: doAutoRange,\n    findExtremes: findExtremes,\n    concatExtremes: concatExtremes\n};\n\n/**\n * getAutoRange\n *\n * Collects all _extremes values corresponding to a given axis\n * and computes its auto range.\n *\n * Note that getAutoRange uses return values from findExtremes.\n *\n * @param {object} gd:\n *   graph div object with filled-in fullData and fullLayout, in particular\n *   with filled-in '_extremes' containers:\n *   {\n *      val: calcdata value,\n *      pad: extra pixels beyond this value,\n *      extrapad: bool, does this point want 5% extra padding\n *   }\n * @param {object} ax:\n *   full axis object, in particular with filled-in '_traceIndices'\n *   and '_annIndices' / '_shapeIndices' if applicable\n * @return {array}\n *   an array of [min, max]. These are calcdata for log and category axes\n *   and data for linear and date axes.\n *\n * TODO: we want to change log to data as well, but it's hard to do this\n * maintaining backward compatibility. category will always have to use calcdata\n * though, because otherwise values between categories (or outside all categories)\n * would be impossible.\n */\nfunction getAutoRange(gd, ax) {\n    var i, j;\n    var newRange = [];\n\n    var fullLayout = gd._fullLayout;\n    var getPadMin = makePadFn(fullLayout, ax, 0);\n    var getPadMax = makePadFn(fullLayout, ax, 1);\n    var extremes = concatExtremes(gd, ax);\n    var minArray = extremes.min;\n    var maxArray = extremes.max;\n\n    if(minArray.length === 0 || maxArray.length === 0) {\n        return Lib.simpleMap(ax.range, ax.r2l);\n    }\n\n    var minmin = minArray[0].val;\n    var maxmax = maxArray[0].val;\n\n    for(i = 1; i < minArray.length; i++) {\n        if(minmin !== maxmax) break;\n        minmin = Math.min(minmin, minArray[i].val);\n    }\n    for(i = 1; i < maxArray.length; i++) {\n        if(minmin !== maxmax) break;\n        maxmax = Math.max(maxmax, maxArray[i].val);\n    }\n\n    var autorange = ax.autorange;\n    var axReverse =\n        autorange === 'reversed' ||\n        autorange === 'min reversed' ||\n        autorange === 'max reversed';\n\n    if(!axReverse && ax.range) {\n        var rng = Lib.simpleMap(ax.range, ax.r2l);\n        axReverse = rng[1] < rng[0];\n    }\n\n    // one-time setting to easily reverse the axis\n    // when plotting from code\n    if(ax.autorange === 'reversed') {\n        ax.autorange = true;\n    }\n\n    var rangeMode = ax.rangemode;\n    var toZero = rangeMode === 'tozero';\n    var nonNegative = rangeMode === 'nonnegative';\n    var axLen = ax._length;\n    // don't allow padding to reduce the data to < 10% of the length\n    var minSpan = axLen / 10;\n\n    var mbest = 0;\n    var minpt, maxpt, minbest, maxbest, dp, dv;\n\n    for(i = 0; i < minArray.length; i++) {\n        minpt = minArray[i];\n        for(j = 0; j < maxArray.length; j++) {\n            maxpt = maxArray[j];\n            dv = maxpt.val - minpt.val - calcBreaksLength(ax, minpt.val, maxpt.val);\n            if(dv > 0) {\n                dp = axLen - getPadMin(minpt) - getPadMax(maxpt);\n                if(dp > minSpan) {\n                    if(dv / dp > mbest) {\n                        minbest = minpt;\n                        maxbest = maxpt;\n                        mbest = dv / dp;\n                    }\n                } else if(dv / axLen > mbest) {\n                    // in case of padding longer than the axis\n                    // at least include the unpadded data values.\n                    minbest = {val: minpt.val, nopad: 1};\n                    maxbest = {val: maxpt.val, nopad: 1};\n                    mbest = dv / axLen;\n                }\n            }\n        }\n    }\n\n    function maximumPad(prev, pt) {\n        return Math.max(prev, getPadMax(pt));\n    }\n\n    if(minmin === maxmax) {\n        var lower = minmin - 1;\n        var upper = minmin + 1;\n        if(toZero) {\n            if(minmin === 0) {\n                // The only value we have on this axis is 0, and we want to\n                // autorange so zero is one end.\n                // In principle this could be [0, 1] or [-1, 0] but usually\n                // 'tozero' pins 0 to the low end, so follow that.\n                newRange = [0, 1];\n            } else {\n                var maxPad = (minmin > 0 ? maxArray : minArray).reduce(maximumPad, 0);\n                // we're pushing a single value away from the edge due to its\n                // padding, with the other end clamped at zero\n                // 0.5 means don't push it farther than the center.\n                var rangeEnd = minmin / (1 - Math.min(0.5, maxPad / axLen));\n                newRange = minmin > 0 ? [0, rangeEnd] : [rangeEnd, 0];\n            }\n        } else if(nonNegative) {\n            newRange = [Math.max(0, lower), Math.max(1, upper)];\n        } else {\n            newRange = [lower, upper];\n        }\n    } else {\n        if(toZero) {\n            if(minbest.val >= 0) {\n                minbest = {val: 0, nopad: 1};\n            }\n            if(maxbest.val <= 0) {\n                maxbest = {val: 0, nopad: 1};\n            }\n        } else if(nonNegative) {\n            if(minbest.val - mbest * getPadMin(minbest) < 0) {\n                minbest = {val: 0, nopad: 1};\n            }\n            if(maxbest.val <= 0) {\n                maxbest = {val: 1, nopad: 1};\n            }\n        }\n\n        // in case it changed again...\n        mbest = (maxbest.val - minbest.val - calcBreaksLength(ax, minpt.val, maxpt.val)) /\n            (axLen - getPadMin(minbest) - getPadMax(maxbest));\n\n        newRange = [\n            minbest.val - mbest * getPadMin(minbest),\n            maxbest.val + mbest * getPadMax(maxbest)\n        ];\n    }\n\n    newRange = applyAutorangeOptions(newRange, ax);\n\n    if(ax.limitRange) ax.limitRange();\n\n    // maintain reversal\n    if(axReverse) newRange.reverse();\n\n    return Lib.simpleMap(newRange, ax.l2r || Number);\n}\n\n// find axis rangebreaks in [v0,v1] and compute its length in value space\nfunction calcBreaksLength(ax, v0, v1) {\n    var lBreaks = 0;\n    if(ax.rangebreaks) {\n        var rangebreaksOut = ax.locateBreaks(v0, v1);\n        for(var i = 0; i < rangebreaksOut.length; i++) {\n            var brk = rangebreaksOut[i];\n            lBreaks += brk.max - brk.min;\n        }\n    }\n    return lBreaks;\n}\n\n/*\n * calculate the pixel padding for ax._min and ax._max entries with\n * optional extrapad as 5% of the total axis length\n */\nfunction makePadFn(fullLayout, ax, max) {\n    // 5% padding for points that specify extrapad: true\n    var extrappad = 0.05 * ax._length;\n\n    var anchorAxis = ax._anchorAxis || {};\n\n    if(\n        (ax.ticklabelposition || '').indexOf('inside') !== -1 ||\n        (anchorAxis.ticklabelposition || '').indexOf('inside') !== -1\n    ) {\n        var axReverse = ax.isReversed();\n        if(!axReverse) {\n            var rng = Lib.simpleMap(ax.range, ax.r2l);\n            axReverse = rng[1] < rng[0];\n        }\n        if(axReverse) max = !max;\n    }\n\n    var zero = 0;\n    if(!isLinked(fullLayout, ax._id)) {\n        zero = padInsideLabelsOnAnchorAxis(fullLayout, ax, max);\n    }\n    extrappad = Math.max(zero, extrappad);\n\n    // domain-constrained axes: base extrappad on the unconstrained\n    // domain so it's consistent as the domain changes\n    if((ax.constrain === 'domain') && ax._inputDomain) {\n        extrappad *= (ax._inputDomain[1] - ax._inputDomain[0]) /\n            (ax.domain[1] - ax.domain[0]);\n    }\n\n    return function getPad(pt) {\n        if(pt.nopad) return 0;\n        return pt.pad + (pt.extrapad ? extrappad : zero);\n    };\n}\n\nvar TEXTPAD = 3;\n\nfunction padInsideLabelsOnAnchorAxis(fullLayout, ax, max) {\n    var pad = 0;\n\n    var isX = ax._id.charAt(0) === 'x';\n\n    for(var subplot in fullLayout._plots) {\n        var plotinfo = fullLayout._plots[subplot];\n\n        if(ax._id !== plotinfo.xaxis._id && ax._id !== plotinfo.yaxis._id) continue;\n\n        var anchorAxis = (isX ? plotinfo.yaxis : plotinfo.xaxis) || {};\n\n        if((anchorAxis.ticklabelposition || '').indexOf('inside') !== -1) {\n            // increase padding to make more room for inside tick labels of the counter axis\n            if((\n                !max && (\n                    anchorAxis.side === 'left' ||\n                    anchorAxis.side === 'bottom'\n                )\n            ) || (\n                max && (\n                    anchorAxis.side === 'top' ||\n                    anchorAxis.side === 'right'\n                )\n            )) {\n                if(anchorAxis._vals) {\n                    var rad = Lib.deg2rad(anchorAxis._tickAngles[anchorAxis._id + 'tick'] || 0);\n                    var cosA = Math.abs(Math.cos(rad));\n                    var sinA = Math.abs(Math.sin(rad));\n\n                    // no stashed bounding boxes - stash bounding boxes\n                    if(!anchorAxis._vals[0].bb) {\n                        var cls = anchorAxis._id + 'tick';\n                        var tickLabels = anchorAxis._selections[cls];\n                        tickLabels.each(function(d) {\n                            var thisLabel = d3.select(this);\n                            var mathjaxGroup = thisLabel.select('.text-math-group');\n                            if(mathjaxGroup.empty()) {\n                                d.bb = Drawing.bBox(thisLabel.node());\n                            }\n                        });\n                    }\n\n                    // use bounding boxes\n                    for(var i = 0; i < anchorAxis._vals.length; i++) {\n                        var t = anchorAxis._vals[i];\n                        var bb = t.bb;\n\n                        if(bb) {\n                            var w = 2 * TEXTPAD + bb.width;\n                            var h = 2 * TEXTPAD + bb.height;\n\n                            pad = Math.max(pad, isX ?\n                                Math.max(w * cosA, h * sinA) :\n                                Math.max(h * cosA, w * sinA)\n                            );\n                        }\n                    }\n                }\n\n                if(anchorAxis.ticks === 'inside' && anchorAxis.ticklabelposition === 'inside') {\n                    pad += anchorAxis.ticklen || 0;\n                }\n            }\n        }\n    }\n\n    return pad;\n}\n\nfunction concatExtremes(gd, ax, noMatch) {\n    var axId = ax._id;\n    var fullData = gd._fullData;\n    var fullLayout = gd._fullLayout;\n    var minArray = [];\n    var maxArray = [];\n    var i, j, d;\n\n    function _concat(cont, indices) {\n        for(i = 0; i < indices.length; i++) {\n            var item = cont[indices[i]];\n            var extremes = (item._extremes || {})[axId];\n            if(item.visible === true && extremes) {\n                for(j = 0; j < extremes.min.length; j++) {\n                    d = extremes.min[j];\n                    collapseMinArray(minArray, d.val, d.pad, {extrapad: d.extrapad});\n                }\n                for(j = 0; j < extremes.max.length; j++) {\n                    d = extremes.max[j];\n                    collapseMaxArray(maxArray, d.val, d.pad, {extrapad: d.extrapad});\n                }\n            }\n        }\n    }\n\n    _concat(fullData, ax._traceIndices);\n    _concat(fullLayout.annotations || [], ax._annIndices || []);\n    _concat(fullLayout.shapes || [], ax._shapeIndices || []);\n\n    // Include the extremes from other matched axes with this one\n    if(ax._matchGroup && !noMatch) {\n        for(var axId2 in ax._matchGroup) {\n            if(axId2 !== ax._id) {\n                var ax2 = getFromId(gd, axId2);\n                var extremes2 = concatExtremes(gd, ax2, true);\n                // convert padding on the second axis to the first with lenRatio\n                var lenRatio = ax._length / ax2._length;\n                for(j = 0; j < extremes2.min.length; j++) {\n                    d = extremes2.min[j];\n                    collapseMinArray(minArray, d.val, d.pad * lenRatio, {extrapad: d.extrapad});\n                }\n                for(j = 0; j < extremes2.max.length; j++) {\n                    d = extremes2.max[j];\n                    collapseMaxArray(maxArray, d.val, d.pad * lenRatio, {extrapad: d.extrapad});\n                }\n            }\n        }\n    }\n\n    return {min: minArray, max: maxArray};\n}\n\nfunction doAutoRange(gd, ax, presetRange) {\n    ax.setScale();\n\n    if(ax.autorange) {\n        ax.range = presetRange ? presetRange.slice() : getAutoRange(gd, ax);\n\n        ax._r = ax.range.slice();\n        ax._rl = Lib.simpleMap(ax._r, ax.r2l);\n\n        // doAutoRange will get called on fullLayout,\n        // but we want to report its results back to layout\n\n        var axIn = ax._input;\n\n        // before we edit _input, store preGUI values\n        var edits = {};\n        edits[ax._attr + '.range'] = ax.range;\n        edits[ax._attr + '.autorange'] = ax.autorange;\n        Registry.call('_storeDirectGUIEdit', gd.layout, gd._fullLayout._preGUI, edits);\n\n        axIn.range = ax.range.slice();\n        axIn.autorange = ax.autorange;\n    }\n\n    var anchorAx = ax._anchorAxis;\n\n    if(anchorAx && anchorAx.rangeslider) {\n        var axeRangeOpts = anchorAx.rangeslider[ax._name];\n        if(axeRangeOpts) {\n            if(axeRangeOpts.rangemode === 'auto') {\n                axeRangeOpts.range = getAutoRange(gd, ax);\n            }\n        }\n        anchorAx._input.rangeslider[ax._name] = Lib.extendFlat({}, axeRangeOpts);\n    }\n}\n\n/**\n * findExtremes\n *\n * Find min/max extremes of an array of coordinates on a given axis.\n *\n * Note that findExtremes is called during `calc`, when we don't yet know the axis\n * length; all the inputs should be based solely on the trace data, nothing\n * about the axis layout.\n *\n * Note that `ppad` and `vpad` as well as their asymmetric variants refer to\n * the before and after padding of the passed `data` array, not to the whole axis.\n *\n * @param {object} ax: full axis object\n *   relies on\n *   - ax.type\n *   - ax._m (just its sign)\n *   - ax.d2l\n * @param {array} data:\n *  array of numbers (i.e. already run though ax.d2c)\n * @param {object} opts:\n *  available keys are:\n *      vpad: (number or number array) pad values (data value +-vpad)\n *      ppad: (number or number array) pad pixels (pixel location +-ppad)\n *      ppadplus, ppadminus, vpadplus, vpadminus:\n *          separate padding for each side, overrides symmetric\n *      padded: (boolean) add 5% padding to both ends\n *          (unless one end is overridden by tozero)\n *      tozero: (boolean) make sure to include zero if axis is linear,\n *          and make it a tight bound if possible\n *      vpadLinearized: (boolean) whether or not vpad (or vpadplus/vpadminus)\n *          is linearized (for log scale axes)\n *\n * @return {object}\n *  - min {array of objects}\n *  - max {array of objects}\n *  each object item has fields:\n *    - val {number}\n *    - pad {number}\n *    - extrappad {number}\n *  - opts {object}: a ref to the passed \"options\" object\n */\nfunction findExtremes(ax, data, opts) {\n    if(!opts) opts = {};\n    if(!ax._m) ax.setScale();\n\n    var minArray = [];\n    var maxArray = [];\n\n    var len = data.length;\n    var extrapad = opts.padded || false;\n    var tozero = opts.tozero && (ax.type === 'linear' || ax.type === '-');\n    var isLog = ax.type === 'log';\n    var hasArrayOption = false;\n    var vpadLinearized = opts.vpadLinearized || false;\n    var i, v, di, dmin, dmax, ppadiplus, ppadiminus, vmin, vmax;\n\n    function makePadAccessor(item) {\n        if(Array.isArray(item)) {\n            hasArrayOption = true;\n            return function(i) { return Math.max(Number(item[i]||0), 0); };\n        } else {\n            var v = Math.max(Number(item||0), 0);\n            return function() { return v; };\n        }\n    }\n\n    var ppadplus = makePadAccessor((ax._m > 0 ?\n        opts.ppadplus : opts.ppadminus) || opts.ppad || 0);\n    var ppadminus = makePadAccessor((ax._m > 0 ?\n        opts.ppadminus : opts.ppadplus) || opts.ppad || 0);\n    var vpadplus = makePadAccessor(opts.vpadplus || opts.vpad);\n    var vpadminus = makePadAccessor(opts.vpadminus || opts.vpad);\n\n    if(!hasArrayOption) {\n        // with no arrays other than `data` we don't need to consider\n        // every point, only the extreme data points\n        vmin = Infinity;\n        vmax = -Infinity;\n\n        if(isLog) {\n            for(i = 0; i < len; i++) {\n                v = data[i];\n                // data is not linearized yet so we still have to filter out negative logs\n                if(v < vmin && v > 0) vmin = v;\n                if(v > vmax && v < FP_SAFE) vmax = v;\n            }\n        } else {\n            for(i = 0; i < len; i++) {\n                v = data[i];\n                if(v < vmin && v > -FP_SAFE) vmin = v;\n                if(v > vmax && v < FP_SAFE) vmax = v;\n            }\n        }\n\n        data = [vmin, vmax];\n        len = 2;\n    }\n\n    var collapseOpts = {tozero: tozero, extrapad: extrapad};\n\n    function addItem(i) {\n        di = data[i];\n        if(!isNumeric(di)) return;\n        ppadiplus = ppadplus(i);\n        ppadiminus = ppadminus(i);\n\n        if(vpadLinearized) {\n            dmin = ax.c2l(di) - vpadminus(i);\n            dmax = ax.c2l(di) + vpadplus(i);\n        } else {\n            vmin = di - vpadminus(i);\n            vmax = di + vpadplus(i);\n            // special case for log axes: if vpad makes this object span\n            // more than an order of mag, clip it to one order. This is so\n            // we don't have non-positive errors or absurdly large lower\n            // range due to rounding errors\n            if(isLog && vmin < vmax / 10) vmin = vmax / 10;\n\n            dmin = ax.c2l(vmin);\n            dmax = ax.c2l(vmax);\n        }\n\n        if(tozero) {\n            dmin = Math.min(0, dmin);\n            dmax = Math.max(0, dmax);\n        }\n        if(goodNumber(dmin)) {\n            collapseMinArray(minArray, dmin, ppadiminus, collapseOpts);\n        }\n        if(goodNumber(dmax)) {\n            collapseMaxArray(maxArray, dmax, ppadiplus, collapseOpts);\n        }\n    }\n\n    // For efficiency covering monotonic or near-monotonic data,\n    // check a few points at both ends first and then sweep\n    // through the middle\n    var iMax = Math.min(6, len);\n    for(i = 0; i < iMax; i++) addItem(i);\n    for(i = len - 1; i >= iMax; i--) addItem(i);\n\n    return {\n        min: minArray,\n        max: maxArray,\n        opts: opts\n    };\n}\n\nfunction collapseMinArray(array, newVal, newPad, opts) {\n    collapseArray(array, newVal, newPad, opts, lessOrEqual);\n}\n\nfunction collapseMaxArray(array, newVal, newPad, opts) {\n    collapseArray(array, newVal, newPad, opts, greaterOrEqual);\n}\n\n/**\n * collapseArray\n *\n * Takes items from 'array' and compares them to 'newVal', 'newPad'.\n *\n * @param {array} array:\n *  current set of min or max extremes\n * @param {number} newVal:\n *  new value to compare against\n * @param {number} newPad:\n *  pad value associated with 'newVal'\n * @param {object} opts:\n *  - tozero {boolean}\n *  - extrapad {number}\n * @param {function} atLeastAsExtreme:\n *  comparison function, use\n *  - lessOrEqual for min 'array' and\n *  - greaterOrEqual for max 'array'\n *\n * In practice, 'array' is either\n *  - 'extremes[ax._id].min' or\n *  - 'extremes[ax._id].max\n *  found in traces and layout items that affect autorange.\n *\n * Since we don't yet know the relationship between pixels and values\n * (that's what we're trying to figure out!) AND we don't yet know how\n * many pixels `extrapad` represents (it's going to be 5% of the length,\n * but we don't want to have to redo calc just because length changed)\n * two point must satisfy three criteria simultaneously for one to supersede the other:\n *  - at least as extreme a `val`\n *  - at least as big a `pad`\n *  - an unpadded point cannot supersede a padded point, but any other combination can\n *\n * Then:\n * - If the item supersedes the new point, set includeThis false\n * - If the new pt supersedes the item, delete it from 'array'\n */\nfunction collapseArray(array, newVal, newPad, opts, atLeastAsExtreme) {\n    var tozero = opts.tozero;\n    var extrapad = opts.extrapad;\n    var includeThis = true;\n\n    for(var j = 0; j < array.length && includeThis; j++) {\n        var v = array[j];\n        if(atLeastAsExtreme(v.val, newVal) && v.pad >= newPad && (v.extrapad || !extrapad)) {\n            includeThis = false;\n            break;\n        } else if(atLeastAsExtreme(newVal, v.val) && v.pad <= newPad && (extrapad || !v.extrapad)) {\n            array.splice(j, 1);\n            j--;\n        }\n    }\n    if(includeThis) {\n        var clipAtZero = (tozero && newVal === 0);\n        array.push({\n            val: newVal,\n            pad: clipAtZero ? 0 : newPad,\n            extrapad: clipAtZero ? false : extrapad\n        });\n    }\n}\n\n// In order to stop overflow errors, don't consider points\n// too close to the limits of js floating point\nfunction goodNumber(v) {\n    return isNumeric(v) && Math.abs(v) < FP_SAFE;\n}\n\nfunction lessOrEqual(v0, v1) { return v0 <= v1; }\nfunction greaterOrEqual(v0, v1) { return v0 >= v1; }\n\nfunction applyAutorangeMinOptions(v, ax) {\n    var autorangeoptions = ax.autorangeoptions;\n    if(\n        autorangeoptions &&\n        autorangeoptions.minallowed !== undefined &&\n        hasValidMinAndMax(ax, autorangeoptions.minallowed, autorangeoptions.maxallowed)\n    ) {\n        return autorangeoptions.minallowed;\n    }\n\n    if(\n        autorangeoptions &&\n        autorangeoptions.clipmin !== undefined &&\n        hasValidMinAndMax(ax, autorangeoptions.clipmin, autorangeoptions.clipmax)\n    ) {\n        return Math.max(v, ax.d2l(autorangeoptions.clipmin));\n    }\n    return v;\n}\n\nfunction applyAutorangeMaxOptions(v, ax) {\n    var autorangeoptions = ax.autorangeoptions;\n\n    if(\n        autorangeoptions &&\n        autorangeoptions.maxallowed !== undefined &&\n        hasValidMinAndMax(ax, autorangeoptions.minallowed, autorangeoptions.maxallowed)\n    ) {\n        return autorangeoptions.maxallowed;\n    }\n\n    if(\n        autorangeoptions &&\n        autorangeoptions.clipmax !== undefined &&\n        hasValidMinAndMax(ax, autorangeoptions.clipmin, autorangeoptions.clipmax)\n    ) {\n        return Math.min(v, ax.d2l(autorangeoptions.clipmax));\n    }\n\n    return v;\n}\n\nfunction hasValidMinAndMax(ax, min, max) {\n    // in case both min and max are defined, ensure min < max\n    if(\n        min !== undefined &&\n        max !== undefined\n    ) {\n        min = ax.d2l(min);\n        max = ax.d2l(max);\n        return min < max;\n    }\n    return true;\n}\n\n// this function should be (and is) called before reversing the range\n// so range[0] is the minimum and range[1] is the maximum\nfunction applyAutorangeOptions(range, ax) {\n    if(!ax || !ax.autorangeoptions) return range;\n\n    var min = range[0];\n    var max = range[1];\n\n    var include = ax.autorangeoptions.include;\n    if(include !== undefined) {\n        var lMin = ax.d2l(min);\n        var lMax = ax.d2l(max);\n\n        if(!Lib.isArrayOrTypedArray(include)) include = [include];\n        for(var i = 0; i < include.length; i++) {\n            var v = ax.d2l(include[i]);\n            if(lMin >= v) {\n                lMin = v;\n                min = v;\n            }\n            if(lMax <= v) {\n                lMax = v;\n                max = v;\n            }\n        }\n    }\n\n    min = applyAutorangeMinOptions(min, ax);\n    max = applyAutorangeMaxOptions(max, ax);\n\n    return [min, max];\n}\n","'use strict';\n\nmodule.exports = function handleAutorangeOptionsDefaults(coerce, autorange, range) {\n    var minRange, maxRange;\n    if(range) {\n        var isReversed = (\n            autorange === 'reversed' ||\n            autorange === 'min reversed' ||\n            autorange === 'max reversed'\n        );\n\n        minRange = range[isReversed ? 1 : 0];\n        maxRange = range[isReversed ? 0 : 1];\n    }\n\n    var minallowed = coerce('autorangeoptions.minallowed', maxRange === null ? minRange : undefined);\n    var maxallowed = coerce('autorangeoptions.maxallowed', minRange === null ? maxRange : undefined);\n\n    if(minallowed === undefined) coerce('autorangeoptions.clipmin');\n    if(maxallowed === undefined) coerce('autorangeoptions.clipmax');\n\n    coerce('autorangeoptions.include');\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar isNumeric = require('fast-isnumeric');\nvar Plots = require('../../plots/plots');\n\nvar Registry = require('../../registry');\nvar Lib = require('../../lib');\nvar strTranslate = Lib.strTranslate;\nvar svgTextUtils = require('../../lib/svg_text_utils');\nvar Titles = require('../../components/titles');\nvar Color = require('../../components/color');\nvar Drawing = require('../../components/drawing');\n\nvar axAttrs = require('./layout_attributes');\nvar cleanTicks = require('./clean_ticks');\n\nvar constants = require('../../constants/numerical');\nvar ONEMAXYEAR = constants.ONEMAXYEAR;\nvar ONEAVGYEAR = constants.ONEAVGYEAR;\nvar ONEMINYEAR = constants.ONEMINYEAR;\nvar ONEMAXQUARTER = constants.ONEMAXQUARTER;\nvar ONEAVGQUARTER = constants.ONEAVGQUARTER;\nvar ONEMINQUARTER = constants.ONEMINQUARTER;\nvar ONEMAXMONTH = constants.ONEMAXMONTH;\nvar ONEAVGMONTH = constants.ONEAVGMONTH;\nvar ONEMINMONTH = constants.ONEMINMONTH;\nvar ONEWEEK = constants.ONEWEEK;\nvar ONEDAY = constants.ONEDAY;\nvar HALFDAY = ONEDAY / 2;\nvar ONEHOUR = constants.ONEHOUR;\nvar ONEMIN = constants.ONEMIN;\nvar ONESEC = constants.ONESEC;\nvar MINUS_SIGN = constants.MINUS_SIGN;\nvar BADNUM = constants.BADNUM;\n\nvar ZERO_PATH = { K: 'zeroline' };\nvar GRID_PATH = { K: 'gridline', L: 'path' };\nvar MINORGRID_PATH = { K: 'minor-gridline', L: 'path' };\nvar TICK_PATH = { K: 'tick', L: 'path' };\nvar TICK_TEXT = { K: 'tick', L: 'text' };\nvar MARGIN_MAPPING = {\n    width: ['x', 'r', 'l', 'xl', 'xr'],\n    height: ['y', 't', 'b', 'yt', 'yb'],\n    right: ['r', 'xr'],\n    left: ['l', 'xl'],\n    top: ['t', 'yt'],\n    bottom: ['b', 'yb']\n};\n\nvar alignmentConstants = require('../../constants/alignment');\nvar MID_SHIFT = alignmentConstants.MID_SHIFT;\nvar CAP_SHIFT = alignmentConstants.CAP_SHIFT;\nvar LINE_SPACING = alignmentConstants.LINE_SPACING;\nvar OPPOSITE_SIDE = alignmentConstants.OPPOSITE_SIDE;\n\nvar TEXTPAD = 3;\n\nvar axes = module.exports = {};\n\naxes.setConvert = require('./set_convert');\nvar autoType = require('./axis_autotype');\n\nvar axisIds = require('./axis_ids');\nvar idSort = axisIds.idSort;\nvar isLinked = axisIds.isLinked;\n\n// tight coupling to chart studio\naxes.id2name = axisIds.id2name;\naxes.name2id = axisIds.name2id;\naxes.cleanId = axisIds.cleanId;\naxes.list = axisIds.list;\naxes.listIds = axisIds.listIds;\naxes.getFromId = axisIds.getFromId;\naxes.getFromTrace = axisIds.getFromTrace;\n\nvar autorange = require('./autorange');\naxes.getAutoRange = autorange.getAutoRange;\naxes.findExtremes = autorange.findExtremes;\n\nvar epsilon = 0.0001;\nfunction expandRange(range) {\n    var delta = (range[1] - range[0]) * epsilon;\n    return [\n        range[0] - delta,\n        range[1] + delta\n    ];\n}\n\n/*\n * find the list of possible axes to reference with an xref or yref attribute\n * and coerce it to that list\n *\n * attr: the attribute we're generating a reference for. Should end in 'x' or 'y'\n *     but can be prefixed, like 'ax' for annotation's arrow x\n * dflt: the default to coerce to, or blank to use the first axis (falling back on\n *     extraOption if there is no axis)\n * extraOption: aside from existing axes with this letter, what non-axis value is allowed?\n *     Only required if it's different from `dflt`\n */\naxes.coerceRef = function(containerIn, containerOut, gd, attr, dflt, extraOption) {\n    var axLetter = attr.charAt(attr.length - 1);\n    var axlist = gd._fullLayout._subplots[axLetter + 'axis'];\n    var refAttr = attr + 'ref';\n    var attrDef = {};\n\n    if(!dflt) dflt = axlist[0] || (typeof extraOption === 'string' ? extraOption : extraOption[0]);\n    if(!extraOption) extraOption = dflt;\n    axlist = axlist.concat(axlist.map(function(x) { return x + ' domain'; }));\n\n    // data-ref annotations are not supported in gl2d yet\n\n    attrDef[refAttr] = {\n        valType: 'enumerated',\n        values: axlist.concat(extraOption ?\n            (typeof extraOption === 'string' ? [extraOption] : extraOption) :\n            []),\n        dflt: dflt\n    };\n\n    // xref, yref\n    return Lib.coerce(containerIn, containerOut, attrDef, refAttr);\n};\n\n/*\n * Get the type of an axis reference. This can be 'range', 'domain', or 'paper'.\n * This assumes ar is a valid axis reference and returns 'range' if it doesn't\n * match the patterns for 'paper' or 'domain'.\n *\n * ar: the axis reference string\n *\n */\naxes.getRefType = function(ar) {\n    if(ar === undefined) { return ar; }\n    if(ar === 'paper') { return 'paper'; }\n    if(ar === 'pixel') { return 'pixel'; }\n    if(/( domain)$/.test(ar)) { return 'domain'; } else { return 'range'; }\n};\n\n/*\n * coerce position attributes (range-type) that can be either on axes or absolute\n * (paper or pixel) referenced. The biggest complication here is that we don't know\n * before looking at the axis whether the value must be a number or not (it may be\n * a date string), so we can't use the regular valType='number' machinery\n *\n * axRef (string): the axis this position is referenced to, or:\n *     paper: fraction of the plot area\n *     pixel: pixels relative to some starting position\n * attr (string): the attribute in containerOut we are coercing\n * dflt (number): the default position, as a fraction or pixels. If the attribute\n *     is to be axis-referenced, this will be converted to an axis data value\n *\n * Also cleans the values, since the attribute definition itself has to say\n * valType: 'any' to handle date axes. This allows us to accept:\n * - for category axes: category names, and convert them here into serial numbers.\n *   Note that this will NOT work for axis range endpoints, because we don't know\n *   the category list yet (it's set by ax.makeCalcdata during calc)\n *   but it works for component (note, shape, images) positions.\n * - for date axes: JS Dates or milliseconds, and convert to date strings\n * - for other types: coerce them to numbers\n */\naxes.coercePosition = function(containerOut, gd, coerce, axRef, attr, dflt) {\n    var cleanPos, pos;\n    var axRefType = axes.getRefType(axRef);\n    if(axRefType !== 'range') {\n        cleanPos = Lib.ensureNumber;\n        pos = coerce(attr, dflt);\n    } else {\n        var ax = axes.getFromId(gd, axRef);\n        dflt = ax.fraction2r(dflt);\n        pos = coerce(attr, dflt);\n        cleanPos = ax.cleanPos;\n    }\n    containerOut[attr] = cleanPos(pos);\n};\n\naxes.cleanPosition = function(pos, gd, axRef) {\n    var cleanPos = (axRef === 'paper' || axRef === 'pixel') ?\n        Lib.ensureNumber :\n        axes.getFromId(gd, axRef).cleanPos;\n\n    return cleanPos(pos);\n};\n\naxes.redrawComponents = function(gd, axIds) {\n    axIds = axIds ? axIds : axes.listIds(gd);\n\n    var fullLayout = gd._fullLayout;\n\n    function _redrawOneComp(moduleName, methodName, stashName, shortCircuit) {\n        var method = Registry.getComponentMethod(moduleName, methodName);\n        var stash = {};\n\n        for(var i = 0; i < axIds.length; i++) {\n            var ax = fullLayout[axes.id2name(axIds[i])];\n            var indices = ax[stashName];\n\n            for(var j = 0; j < indices.length; j++) {\n                var ind = indices[j];\n\n                if(!stash[ind]) {\n                    method(gd, ind);\n                    stash[ind] = 1;\n                    // once is enough for images (which doesn't use the `i` arg anyway)\n                    if(shortCircuit) return;\n                }\n            }\n        }\n    }\n\n    // annotations and shapes 'draw' method is slow,\n    // use the finer-grained 'drawOne' method instead\n    _redrawOneComp('annotations', 'drawOne', '_annIndices');\n    _redrawOneComp('shapes', 'drawOne', '_shapeIndices');\n    _redrawOneComp('images', 'draw', '_imgIndices', true);\n    _redrawOneComp('selections', 'drawOne', '_selectionIndices');\n};\n\nvar getDataConversions = axes.getDataConversions = function(gd, trace, target, targetArray) {\n    var ax;\n\n    // If target points to an axis, use the type we already have for that\n    // axis to find the data type. Otherwise use the values to autotype.\n    var d2cTarget = (target === 'x' || target === 'y' || target === 'z') ?\n        target :\n        targetArray;\n\n    // In the case of an array target, make a mock data array\n    // and call supplyDefaults to the data type and\n    // setup the data-to-calc method.\n    if(Lib.isArrayOrTypedArray(d2cTarget)) {\n        ax = {\n            type: autoType(targetArray, undefined, {\n                autotypenumbers: gd._fullLayout.autotypenumbers\n            }),\n            _categories: []\n        };\n        axes.setConvert(ax);\n\n        // build up ax._categories (usually done during ax.makeCalcdata()\n        if(ax.type === 'category') {\n            for(var i = 0; i < targetArray.length; i++) {\n                ax.d2c(targetArray[i]);\n            }\n        }\n        // TODO what to do for transforms?\n    } else {\n        ax = axes.getFromTrace(gd, trace, d2cTarget);\n    }\n\n    // if 'target' has corresponding axis\n    // -> use setConvert method\n    if(ax) return {d2c: ax.d2c, c2d: ax.c2d};\n\n    // special case for 'ids'\n    // -> cast to String\n    if(d2cTarget === 'ids') return {d2c: toString, c2d: toString};\n\n    // otherwise (e.g. numeric-array of 'marker.color' or 'marker.size')\n    // -> cast to Number\n\n    return {d2c: toNum, c2d: toNum};\n};\n\nfunction toNum(v) { return +v; }\nfunction toString(v) { return String(v); }\n\naxes.getDataToCoordFunc = function(gd, trace, target, targetArray) {\n    return getDataConversions(gd, trace, target, targetArray).d2c;\n};\n\n// get counteraxis letter for this axis (name or id)\n// this can also be used as the id for default counter axis\naxes.counterLetter = function(id) {\n    var axLetter = id.charAt(0);\n    if(axLetter === 'x') return 'y';\n    if(axLetter === 'y') return 'x';\n};\n\n// incorporate a new minimum difference and first tick into\n// forced\n// note that _forceTick0 is linearized, so needs to be turned into\n// a range value for setting tick0\naxes.minDtick = function(ax, newDiff, newFirst, allow) {\n    // doesn't make sense to do forced min dTick on log or category axes,\n    // and the plot itself may decide to cancel (ie non-grouped bars)\n    if(['log', 'category', 'multicategory'].indexOf(ax.type) !== -1 || !allow) {\n        ax._minDtick = 0;\n    } else if(ax._minDtick === undefined) {\n        // undefined means there's nothing there yet\n\n        ax._minDtick = newDiff;\n        ax._forceTick0 = newFirst;\n    } else if(ax._minDtick) {\n        if((ax._minDtick / newDiff + 1e-6) % 1 < 2e-6 &&\n            // existing minDtick is an integer multiple of newDiff\n            // (within rounding err)\n            // and forceTick0 can be shifted to newFirst\n\n                (((newFirst - ax._forceTick0) / newDiff % 1) +\n                    1.000001) % 1 < 2e-6) {\n            ax._minDtick = newDiff;\n            ax._forceTick0 = newFirst;\n        } else if((newDiff / ax._minDtick + 1e-6) % 1 > 2e-6 ||\n            // if the converse is true (newDiff is a multiple of minDtick and\n            // newFirst can be shifted to forceTick0) then do nothing - same\n            // forcing stands. Otherwise, cancel forced minimum\n\n                (((newFirst - ax._forceTick0) / ax._minDtick % 1) +\n                    1.000001) % 1 > 2e-6) {\n            ax._minDtick = 0;\n        }\n    }\n};\n\n// save a copy of the initial axis ranges in fullLayout\n// use them in mode bar and dblclick events\naxes.saveRangeInitial = function(gd, overwrite) {\n    var axList = axes.list(gd, '', true);\n    var hasOneAxisChanged = false;\n\n    for(var i = 0; i < axList.length; i++) {\n        var ax = axList[i];\n        var isNew =\n            ax._rangeInitial0 === undefined &&\n            ax._rangeInitial1 === undefined;\n\n        var hasChanged = isNew || (\n            ax.range[0] !== ax._rangeInitial0 ||\n            ax.range[1] !== ax._rangeInitial1\n        );\n\n        var autorange = ax.autorange;\n        if((isNew && autorange !== true) || (overwrite && hasChanged)) {\n            ax._rangeInitial0 = (autorange === 'min' || autorange === 'max reversed') ? undefined : ax.range[0];\n            ax._rangeInitial1 = (autorange === 'max' || autorange === 'min reversed') ? undefined : ax.range[1];\n            ax._autorangeInitial = autorange;\n            hasOneAxisChanged = true;\n        }\n    }\n\n    return hasOneAxisChanged;\n};\n\n// save a copy of the initial spike visibility\naxes.saveShowSpikeInitial = function(gd, overwrite) {\n    var axList = axes.list(gd, '', true);\n    var hasOneAxisChanged = false;\n    var allSpikesEnabled = 'on';\n\n    for(var i = 0; i < axList.length; i++) {\n        var ax = axList[i];\n        var isNew = (ax._showSpikeInitial === undefined);\n        var hasChanged = isNew || !(ax.showspikes === ax._showspikes);\n\n        if(isNew || (overwrite && hasChanged)) {\n            ax._showSpikeInitial = ax.showspikes;\n            hasOneAxisChanged = true;\n        }\n\n        if(allSpikesEnabled === 'on' && !ax.showspikes) {\n            allSpikesEnabled = 'off';\n        }\n    }\n    gd._fullLayout._cartesianSpikesEnabled = allSpikesEnabled;\n    return hasOneAxisChanged;\n};\n\naxes.autoBin = function(data, ax, nbins, is2d, calendar, size) {\n    var dataMin = Lib.aggNums(Math.min, null, data);\n    var dataMax = Lib.aggNums(Math.max, null, data);\n\n    if(ax.type === 'category' || ax.type === 'multicategory') {\n        return {\n            start: dataMin - 0.5,\n            end: dataMax + 0.5,\n            size: Math.max(1, Math.round(size) || 1),\n            _dataSpan: dataMax - dataMin,\n        };\n    }\n\n    if(!calendar) calendar = ax.calendar;\n\n    // piggyback off tick code to make \"nice\" bin sizes and edges\n    var dummyAx;\n    if(ax.type === 'log') {\n        dummyAx = {\n            type: 'linear',\n            range: [dataMin, dataMax]\n        };\n    } else {\n        dummyAx = {\n            type: ax.type,\n            range: Lib.simpleMap([dataMin, dataMax], ax.c2r, 0, calendar),\n            calendar: calendar\n        };\n    }\n    axes.setConvert(dummyAx);\n\n    size = size && cleanTicks.dtick(size, dummyAx.type);\n\n    if(size) {\n        dummyAx.dtick = size;\n        dummyAx.tick0 = cleanTicks.tick0(undefined, dummyAx.type, calendar);\n    } else {\n        var size0;\n        if(nbins) size0 = ((dataMax - dataMin) / nbins);\n        else {\n            // totally auto: scale off std deviation so the highest bin is\n            // somewhat taller than the total number of bins, but don't let\n            // the size get smaller than the 'nice' rounded down minimum\n            // difference between values\n            var distinctData = Lib.distinctVals(data);\n            var msexp = Math.pow(10, Math.floor(\n                Math.log(distinctData.minDiff) / Math.LN10));\n            var minSize = msexp * Lib.roundUp(\n                distinctData.minDiff / msexp, [0.9, 1.9, 4.9, 9.9], true);\n            size0 = Math.max(minSize, 2 * Lib.stdev(data) /\n                Math.pow(data.length, is2d ? 0.25 : 0.4));\n\n            // fallback if ax.d2c output BADNUMs\n            // e.g. when user try to plot categorical bins\n            // on a layout.xaxis.type: 'linear'\n            if(!isNumeric(size0)) size0 = 1;\n        }\n\n        axes.autoTicks(dummyAx, size0);\n    }\n\n    var finalSize = dummyAx.dtick;\n    var binStart = axes.tickIncrement(\n            axes.tickFirst(dummyAx), finalSize, 'reverse', calendar);\n    var binEnd, bincount;\n\n    // check for too many data points right at the edges of bins\n    // (>50% within 1% of bin edges) or all data points integral\n    // and offset the bins accordingly\n    if(typeof finalSize === 'number') {\n        binStart = autoShiftNumericBins(binStart, data, dummyAx, dataMin, dataMax);\n\n        bincount = 1 + Math.floor((dataMax - binStart) / finalSize);\n        binEnd = binStart + bincount * finalSize;\n    } else {\n        // month ticks - should be the only nonlinear kind we have at this point.\n        // dtick (as supplied by axes.autoTick) only has nonlinear values on\n        // date and log axes, but even if you display a histogram on a log axis\n        // we bin it on a linear axis (which one could argue against, but that's\n        // a separate issue)\n        if(dummyAx.dtick.charAt(0) === 'M') {\n            binStart = autoShiftMonthBins(binStart, data, finalSize, dataMin, calendar);\n        }\n\n        // calculate the endpoint for nonlinear ticks - you have to\n        // just increment until you're done\n        binEnd = binStart;\n        bincount = 0;\n        while(binEnd <= dataMax) {\n            binEnd = axes.tickIncrement(binEnd, finalSize, false, calendar);\n            bincount++;\n        }\n    }\n\n    return {\n        start: ax.c2r(binStart, 0, calendar),\n        end: ax.c2r(binEnd, 0, calendar),\n        size: finalSize,\n        _dataSpan: dataMax - dataMin\n    };\n};\n\n\nfunction autoShiftNumericBins(binStart, data, ax, dataMin, dataMax) {\n    var edgecount = 0;\n    var midcount = 0;\n    var intcount = 0;\n    var blankCount = 0;\n\n    function nearEdge(v) {\n        // is a value within 1% of a bin edge?\n        return (1 + (v - binStart) * 100 / ax.dtick) % 100 < 2;\n    }\n\n    for(var i = 0; i < data.length; i++) {\n        if(data[i] % 1 === 0) intcount++;\n        else if(!isNumeric(data[i])) blankCount++;\n\n        if(nearEdge(data[i])) edgecount++;\n        if(nearEdge(data[i] + ax.dtick / 2)) midcount++;\n    }\n    var dataCount = data.length - blankCount;\n\n    if(intcount === dataCount && ax.type !== 'date') {\n        if(ax.dtick < 1) {\n            // all integers: if bin size is <1, it's because\n            // that was specifically requested (large nbins)\n            // so respect that... but center the bins containing\n            // integers on those integers\n\n            binStart = dataMin - 0.5 * ax.dtick;\n        } else {\n            // otherwise start half an integer down regardless of\n            // the bin size, just enough to clear up endpoint\n            // ambiguity about which integers are in which bins.\n\n            binStart -= 0.5;\n            if(binStart + ax.dtick < dataMin) binStart += ax.dtick;\n        }\n    } else if(midcount < dataCount * 0.1) {\n        if(edgecount > dataCount * 0.3 ||\n                nearEdge(dataMin) || nearEdge(dataMax)) {\n            // lots of points at the edge, not many in the middle\n            // shift half a bin\n            var binshift = ax.dtick / 2;\n            binStart += (binStart + binshift < dataMin) ? binshift : -binshift;\n        }\n    }\n    return binStart;\n}\n\n\nfunction autoShiftMonthBins(binStart, data, dtick, dataMin, calendar) {\n    var stats = Lib.findExactDates(data, calendar);\n    // number of data points that needs to be an exact value\n    // to shift that increment to (near) the bin center\n    var threshold = 0.8;\n\n    if(stats.exactDays > threshold) {\n        var numMonths = Number(dtick.substr(1));\n\n        if((stats.exactYears > threshold) && (numMonths % 12 === 0)) {\n            // The exact middle of a non-leap-year is 1.5 days into July\n            // so if we start the bins here, all but leap years will\n            // get hover-labeled as exact years.\n            binStart = axes.tickIncrement(binStart, 'M6', 'reverse') + ONEDAY * 1.5;\n        } else if(stats.exactMonths > threshold) {\n            // Months are not as clean, but if we shift half the *longest*\n            // month (31/2 days) then 31-day months will get labeled exactly\n            // and shorter months will get labeled with the correct month\n            // but shifted 12-36 hours into it.\n            binStart = axes.tickIncrement(binStart, 'M1', 'reverse') + ONEDAY * 15.5;\n        } else {\n            // Shifting half a day is exact, but since these are month bins it\n            // will always give a somewhat odd-looking label, until we do something\n            // smarter like showing the bin boundaries (or the bounds of the actual\n            // data in each bin)\n            binStart -= HALFDAY;\n        }\n        var nextBinStart = axes.tickIncrement(binStart, dtick);\n\n        if(nextBinStart <= dataMin) return nextBinStart;\n    }\n    return binStart;\n}\n\n// ----------------------------------------------------\n// Ticks and grids\n// ----------------------------------------------------\n\n// ensure we have minor tick0 and dtick calculated\naxes.prepMinorTicks = function(mockAx, ax, opts) {\n    if(!ax.minor.dtick) {\n        delete mockAx.dtick;\n        var hasMajor = ax.dtick && isNumeric(ax._tmin);\n        var mockMinorRange;\n        if(hasMajor) {\n            var tick2 = axes.tickIncrement(ax._tmin, ax.dtick, true);\n            // mock range a tiny bit smaller than one major tick interval\n            mockMinorRange = [ax._tmin, tick2 * 0.99 + ax._tmin * 0.01];\n        } else {\n            var rl = Lib.simpleMap(ax.range, ax.r2l);\n            // If we don't have a major dtick, the concept of minor ticks is a little\n            // ambiguous - just take a stab and say minor.nticks should span 1/5 the axis\n            mockMinorRange = [rl[0], 0.8 * rl[0] + 0.2 * rl[1]];\n        }\n        mockAx.range = Lib.simpleMap(mockMinorRange, ax.l2r);\n        mockAx._isMinor = true;\n\n        axes.prepTicks(mockAx, opts);\n\n        if(hasMajor) {\n            var numericMajor = isNumeric(ax.dtick);\n            var numericMinor = isNumeric(mockAx.dtick);\n            var majorNum = numericMajor ? ax.dtick : +ax.dtick.substring(1);\n            var minorNum = numericMinor ? mockAx.dtick : +mockAx.dtick.substring(1);\n            if(numericMajor && numericMinor) {\n                if(!isMultiple(majorNum, minorNum)) {\n                    // give up on minor ticks - outside the below exceptions,\n                    // this can only happen if minor.nticks is smaller than two jumps\n                    // in the auto-tick scale and the first jump is not an even multiple\n                    // (5 -> 2 or for dates 3 ->2, 15 -> 10 etc)  or if you provided\n                    // an explicit dtick, in which case it's fine to give up,\n                    // you can provide an explicit minor.dtick.\n                    if((majorNum === 2 * ONEWEEK) && (minorNum === 3 * ONEDAY)) {\n                        mockAx.dtick = ONEWEEK;\n                    } else if(majorNum === ONEWEEK && !(ax._input.minor || {}).nticks) {\n                        // minor.nticks defaults to 5, but in this one case we want 7,\n                        // so the minor ticks show on all days of the week\n                        mockAx.dtick = ONEDAY;\n                    } else if(isClose(majorNum / minorNum, 2.5)) {\n                        // 5*10^n -> 2*10^n and you've set nticks < 5\n                        // quarters are pretty common, we don't do this by default as it\n                        // would add an extra digit to display, but minor has no labels\n                        mockAx.dtick = majorNum / 2;\n                    } else {\n                        mockAx.dtick = majorNum;\n                    }\n                } else if(majorNum === 2 * ONEWEEK && minorNum === 2 * ONEDAY) {\n                    // this is a weird one: we don't want to automatically choose\n                    // 2-day minor ticks for 2-week major, even though it IS an even multiple,\n                    // because people would expect to see the weeks clearly\n                    mockAx.dtick = ONEWEEK;\n                }\n            } else if(String(ax.dtick).charAt(0) === 'M') {\n                if(numericMinor) {\n                    mockAx.dtick = 'M1';\n                } else {\n                    if(!isMultiple(majorNum, minorNum)) {\n                        // unless you provided an explicit ax.dtick (in which case\n                        // it's OK for us to give up, you can provide an explicit\n                        // minor.dtick too), this can only happen with:\n                        // minor.nticks < 3 and dtick === M3, or\n                        // minor.nticks < 5 and dtick === 5 * 10^n years\n                        // so in all cases we just give up.\n                        mockAx.dtick = ax.dtick;\n                    } else if((majorNum >= 12) && (minorNum === 2)) {\n                        // another special carve-out: for year major ticks, don't show\n                        // 2-month minor ticks, bump to quarters\n                        mockAx.dtick = 'M3';\n                    }\n                }\n            } else if(String(mockAx.dtick).charAt(0) === 'L') {\n                if(String(ax.dtick).charAt(0) === 'L') {\n                    if(!isMultiple(majorNum, minorNum)) {\n                        mockAx.dtick = isClose(majorNum / minorNum, 2.5) ? (ax.dtick / 2) : ax.dtick;\n                    }\n                } else {\n                    mockAx.dtick = 'D1';\n                }\n            } else if(mockAx.dtick === 'D2' && +ax.dtick > 1) {\n                // the D2 log axis tick spacing is confusing for unlabeled minor ticks if\n                // the major dtick is more than one order of magnitude.\n                mockAx.dtick = 1;\n            }\n        }\n        // put back the original range, to use to find the full set of minor ticks\n        mockAx.range = ax.range;\n    }\n    if(ax.minor._tick0Init === undefined) {\n        // ensure identical tick0\n        mockAx.tick0 = ax.tick0;\n    }\n};\n\nfunction isMultiple(bigger, smaller) {\n    return Math.abs((bigger / smaller + 0.5) % 1 - 0.5) < 0.001;\n}\n\nfunction isClose(a, b) {\n    return Math.abs((a / b) - 1) < 0.001;\n}\n\n// ensure we have tick0, dtick, and tick rounding calculated\naxes.prepTicks = function(ax, opts) {\n    var rng = Lib.simpleMap(ax.range, ax.r2l, undefined, undefined, opts);\n\n    // calculate max number of (auto) ticks to display based on plot size\n    if(ax.tickmode === 'auto' || !ax.dtick) {\n        var nt = ax.nticks;\n        var minPx;\n\n        if(!nt) {\n            if(ax.type === 'category' || ax.type === 'multicategory') {\n                minPx = ax.tickfont ? Lib.bigFont(ax.tickfont.size || 12) : 15;\n                nt = ax._length / minPx;\n            } else {\n                minPx = ax._id.charAt(0) === 'y' ? 40 : 80;\n                nt = Lib.constrain(ax._length / minPx, 4, 9) + 1;\n            }\n\n            // radial axes span half their domain,\n            // multiply nticks value by two to get correct number of auto ticks.\n            if(ax._name === 'radialaxis') nt *= 2;\n        }\n\n        if(!(ax.minor && ax.minor.tickmode !== 'array')) {\n            // add a couple of extra digits for filling in ticks when we\n            // have explicit tickvals without tick text\n            if(ax.tickmode === 'array') nt *= 100;\n        }\n\n        ax._roughDTick = Math.abs(rng[1] - rng[0]) / nt;\n        axes.autoTicks(ax, ax._roughDTick);\n\n        // check for a forced minimum dtick\n        if(ax._minDtick > 0 && ax.dtick < ax._minDtick * 2) {\n            ax.dtick = ax._minDtick;\n            ax.tick0 = ax.l2r(ax._forceTick0);\n        }\n    }\n\n    if(ax.ticklabelmode === 'period') {\n        adjustPeriodDelta(ax);\n    }\n\n    // check for missing tick0\n    if(!ax.tick0) {\n        ax.tick0 = (ax.type === 'date') ? '2000-01-01' : 0;\n    }\n\n    // ensure we don't try to make ticks below our minimum precision\n    // see https://github.com/plotly/plotly.js/issues/2892\n    if(ax.type === 'date' && ax.dtick < 0.1) ax.dtick = 0.1;\n\n    // now figure out rounding of tick values\n    autoTickRound(ax);\n};\n\nfunction nMonths(dtick) {\n    return +(dtick.substring(1));\n}\n\nfunction adjustPeriodDelta(ax) { // adjusts ax.dtick and sets ax._definedDelta\n    var definedDelta;\n\n    function mDate() {\n        return !(\n            isNumeric(ax.dtick) ||\n            ax.dtick.charAt(0) !== 'M'\n        );\n    }\n    var isMDate = mDate();\n    var tickformat = axes.getTickFormat(ax);\n    if(tickformat) {\n        var noDtick = ax._dtickInit !== ax.dtick;\n        if(\n            !(/%[fLQsSMX]/.test(tickformat))\n            // %f: microseconds as a decimal number [000000, 999999]\n            // %L: milliseconds as a decimal number [000, 999]\n            // %Q: milliseconds since UNIX epoch\n            // %s: seconds since UNIX epoch\n            // %S: second as a decimal number [00,61]\n            // %M: minute as a decimal number [00,59]\n            // %X: the locale’s time, such as %-I:%M:%S %p\n        ) {\n            if(\n                /%[HI]/.test(tickformat)\n                // %H: hour (24-hour clock) as a decimal number [00,23]\n                // %I: hour (12-hour clock) as a decimal number [01,12]\n            ) {\n                definedDelta = ONEHOUR;\n                if(noDtick && !isMDate && ax.dtick < ONEHOUR) ax.dtick = ONEHOUR;\n            } else if(\n                /%p/.test(tickformat) // %p: either AM or PM\n            ) {\n                definedDelta = HALFDAY;\n                if(noDtick && !isMDate && ax.dtick < HALFDAY) ax.dtick = HALFDAY;\n            } else if(\n                /%[Aadejuwx]/.test(tickformat)\n                // %A: full weekday name\n                // %a: abbreviated weekday name\n                // %d: zero-padded day of the month as a decimal number [01,31]\n                // %e: space-padded day of the month as a decimal number [ 1,31]\n                // %j: day of the year as a decimal number [001,366]\n                // %u: Monday-based (ISO 8601) weekday as a decimal number [1,7]\n                // %w: Sunday-based weekday as a decimal number [0,6]\n                // %x: the locale’s date, such as %-m/%-d/%Y\n            ) {\n                definedDelta = ONEDAY;\n                if(noDtick && !isMDate && ax.dtick < ONEDAY) ax.dtick = ONEDAY;\n            } else if(\n                /%[UVW]/.test(tickformat)\n                // %U: Sunday-based week of the year as a decimal number [00,53]\n                // %V: ISO 8601 week of the year as a decimal number [01, 53]\n                // %W: Monday-based week of the year as a decimal number [00,53]\n            ) {\n                definedDelta = ONEWEEK;\n                if(noDtick && !isMDate && ax.dtick < ONEWEEK) ax.dtick = ONEWEEK;\n            } else if(\n                /%[Bbm]/.test(tickformat)\n                // %B: full month name\n                // %b: abbreviated month name\n                // %m: month as a decimal number [01,12]\n            ) {\n                definedDelta = ONEAVGMONTH;\n                if(noDtick && (\n                    isMDate ? nMonths(ax.dtick) < 1 : ax.dtick < ONEMINMONTH)\n                ) ax.dtick = 'M1';\n            } else if(\n                /%[q]/.test(tickformat)\n                // %q: quarter of the year as a decimal number [1,4]\n            ) {\n                definedDelta = ONEAVGQUARTER;\n                if(noDtick && (\n                    isMDate ? nMonths(ax.dtick) < 3 : ax.dtick < ONEMINQUARTER)\n                ) ax.dtick = 'M3';\n            } else if(\n                /%[Yy]/.test(tickformat)\n                // %Y: year with century as a decimal number, such as 1999\n                // %y: year without century as a decimal number [00,99]\n            ) {\n                definedDelta = ONEAVGYEAR;\n                if(noDtick && (\n                    isMDate ? nMonths(ax.dtick) < 12 : ax.dtick < ONEMINYEAR)\n                ) ax.dtick = 'M12';\n            }\n        }\n    }\n\n    isMDate = mDate();\n    if(isMDate && ax.tick0 === ax._dowTick0) {\n        // discard Sunday/Monday tweaks\n        ax.tick0 = ax._rawTick0;\n    }\n\n    ax._definedDelta = definedDelta;\n}\n\nfunction positionPeriodTicks(tickVals, ax, definedDelta) {\n    for(var i = 0; i < tickVals.length; i++) {\n        var v = tickVals[i].value;\n\n        var a = i;\n        var b = i + 1;\n        if(i < tickVals.length - 1) {\n            a = i;\n            b = i + 1;\n        } else if(i > 0) {\n            a = i - 1;\n            b = i;\n        } else {\n            a = i;\n            b = i;\n        }\n\n        var A = tickVals[a].value;\n        var B = tickVals[b].value;\n        var actualDelta = Math.abs(B - A);\n        var delta = definedDelta || actualDelta;\n        var periodLength = 0;\n\n        if(delta >= ONEMINYEAR) {\n            if(actualDelta >= ONEMINYEAR && actualDelta <= ONEMAXYEAR) {\n                periodLength = actualDelta;\n            } else {\n                periodLength = ONEAVGYEAR;\n            }\n        } else if(definedDelta === ONEAVGQUARTER && delta >= ONEMINQUARTER) {\n            if(actualDelta >= ONEMINQUARTER && actualDelta <= ONEMAXQUARTER) {\n                periodLength = actualDelta;\n            } else {\n                periodLength = ONEAVGQUARTER;\n            }\n        } else if(delta >= ONEMINMONTH) {\n            if(actualDelta >= ONEMINMONTH && actualDelta <= ONEMAXMONTH) {\n                periodLength = actualDelta;\n            } else {\n                periodLength = ONEAVGMONTH;\n            }\n        } else if(definedDelta === ONEWEEK && delta >= ONEWEEK) {\n            periodLength = ONEWEEK;\n        } else if(delta >= ONEDAY) {\n            periodLength = ONEDAY;\n        } else if(definedDelta === HALFDAY && delta >= HALFDAY) {\n            periodLength = HALFDAY;\n        } else if(definedDelta === ONEHOUR && delta >= ONEHOUR) {\n            periodLength = ONEHOUR;\n        }\n\n        var inBetween;\n        if(periodLength >= actualDelta) {\n            // ensure new label positions remain between ticks\n            periodLength = actualDelta;\n            inBetween = true;\n        }\n\n        var endPeriod = v + periodLength;\n        if(ax.rangebreaks && periodLength > 0) {\n            var nAll = 84; // highly divisible 7 * 12\n            var n = 0;\n            for(var c = 0; c < nAll; c++) {\n                var r = (c + 0.5) / nAll;\n                if(ax.maskBreaks(v * (1 - r) + r * endPeriod) !== BADNUM) n++;\n            }\n            periodLength *= n / nAll;\n\n            if(!periodLength) {\n                tickVals[i].drop = true;\n            }\n\n            if(inBetween && actualDelta > ONEWEEK) periodLength = actualDelta; // center monthly & longer periods\n        }\n\n        if(\n            periodLength > 0 || // not instant\n            i === 0 // taking care first tick added\n        ) {\n            tickVals[i].periodX = v + periodLength / 2;\n        }\n    }\n}\n\n// calculate the ticks: text, values, positioning\n// if ticks are set to automatic, determine the right values (tick0,dtick)\n// in any case, set tickround to # of digits to round tick labels to,\n// or codes to this effect for log and date scales\naxes.calcTicks = function calcTicks(ax, opts) {\n    var type = ax.type;\n    var calendar = ax.calendar;\n    var ticklabelstep = ax.ticklabelstep;\n    var isPeriod = ax.ticklabelmode === 'period';\n\n    var rng = Lib.simpleMap(ax.range, ax.r2l, undefined, undefined, opts);\n    var axrev = (rng[1] < rng[0]);\n    var minRange = Math.min(rng[0], rng[1]);\n    var maxRange = Math.max(rng[0], rng[1]);\n\n    var maxTicks = Math.max(1000, ax._length || 0);\n\n    var ticksOut = [];\n    var minorTicks = [];\n\n    var tickVals = [];\n    var minorTickVals = [];\n\n    var hasMinor = ax.minor && (ax.minor.ticks || ax.minor.showgrid);\n\n    // calc major first\n    for(var major = 1; major >= (hasMinor ? 0 : 1); major--) {\n        var isMinor = !major;\n\n        if(major) {\n            ax._dtickInit = ax.dtick;\n            ax._tick0Init = ax.tick0;\n        } else {\n            ax.minor._dtickInit = ax.minor.dtick;\n            ax.minor._tick0Init = ax.minor.tick0;\n        }\n\n        var mockAx = major ? ax : Lib.extendFlat({}, ax, ax.minor);\n\n        if(isMinor) {\n            axes.prepMinorTicks(mockAx, ax, opts);\n        } else {\n            axes.prepTicks(mockAx, opts);\n        }\n\n        // now that we've figured out the auto values for formatting\n        // in case we're missing some ticktext, we can break out for array ticks\n        if(mockAx.tickmode === 'array') {\n            if(major) {\n                tickVals = [];\n                ticksOut = arrayTicks(ax, !isMinor);\n            } else {\n                minorTickVals = [];\n                minorTicks = arrayTicks(ax, !isMinor);\n            }\n            continue;\n        }\n\n        // fill tickVals based on overlaying axis\n        if(mockAx.tickmode === 'sync') {\n            tickVals = [];\n            ticksOut = syncTicks(ax);\n            continue;\n        }\n\n        // add a tiny bit so we get ticks which may have rounded out\n        var exRng = expandRange(rng);\n        var startTick = exRng[0];\n        var endTick = exRng[1];\n\n        var numDtick = isNumeric(mockAx.dtick);\n        var isDLog = (type === 'log') && !(numDtick || mockAx.dtick.charAt(0) === 'L');\n\n        // find the first tick\n        var x0 = axes.tickFirst(mockAx, opts);\n\n        if(major) {\n            ax._tmin = x0;\n\n            // No visible ticks? Quit.\n            // I've only seen this on category axes with all categories off the edge.\n            if((x0 < startTick) !== axrev) break;\n\n            // return the full set of tick vals\n            if(type === 'category' || type === 'multicategory') {\n                endTick = (axrev) ? Math.max(-0.5, endTick) :\n                    Math.min(ax._categories.length - 0.5, endTick);\n            }\n        }\n\n        var prevX = null;\n        var x = x0;\n        var majorId;\n\n        if(major) {\n            // ids for ticklabelstep\n            var _dTick;\n            if(numDtick) {\n                _dTick = ax.dtick;\n            } else {\n                if(type === 'date') {\n                    if(typeof ax.dtick === 'string' && ax.dtick.charAt(0) === 'M') {\n                        _dTick = ONEAVGMONTH * ax.dtick.substring(1);\n                    }\n                } else {\n                    _dTick = ax._roughDTick;\n                }\n            }\n\n            majorId = Math.round((\n                ax.r2l(x) -\n                ax.r2l(ax.tick0)\n            ) / _dTick) - 1;\n        }\n\n        var dtick = mockAx.dtick;\n\n        if(mockAx.rangebreaks && mockAx._tick0Init !== mockAx.tick0) {\n            // adjust tick0\n            x = moveOutsideBreak(x, ax);\n            if(!axrev) {\n                x = axes.tickIncrement(x, dtick, !axrev, calendar);\n            }\n        }\n\n        if(major && isPeriod) {\n            // add one item to label period before tick0\n            x = axes.tickIncrement(x, dtick, !axrev, calendar);\n            majorId--;\n        }\n\n        for(;\n            axrev ?\n                (x >= endTick) :\n                (x <= endTick);\n            x = axes.tickIncrement(\n                x,\n                dtick,\n                axrev,\n                calendar\n            )\n        ) {\n            if(major) majorId++;\n\n            if(mockAx.rangebreaks) {\n                if(!axrev) {\n                    if(x < startTick) continue;\n                    if(mockAx.maskBreaks(x) === BADNUM && moveOutsideBreak(x, mockAx) >= maxRange) break;\n                }\n            }\n\n            // prevent infinite loops - no more than one tick per pixel,\n            // and make sure each value is different from the previous\n            if(tickVals.length > maxTicks || x === prevX) break;\n            prevX = x;\n\n            var obj = { value: x };\n\n            if(major) {\n                if(isDLog && (x !== (x | 0))) {\n                    obj.simpleLabel = true;\n                }\n\n                if(ticklabelstep > 1 && majorId % ticklabelstep) {\n                    obj.skipLabel = true;\n                }\n\n                tickVals.push(obj);\n            } else {\n                obj.minor = true;\n\n                minorTickVals.push(obj);\n            }\n        }\n    }\n\n    if(hasMinor) {\n        var canOverlap =\n            (ax.minor.ticks === 'inside' && ax.ticks === 'outside') ||\n            (ax.minor.ticks === 'outside' && ax.ticks === 'inside');\n\n        if(!canOverlap) {\n            // remove duplicate minors\n\n            var majorValues = tickVals.map(function(d) { return d.value; });\n\n            var list = [];\n            for(var k = 0; k < minorTickVals.length; k++) {\n                var T = minorTickVals[k];\n                var v = T.value;\n                if(majorValues.indexOf(v) !== -1) {\n                    continue;\n                }\n                var found = false;\n                for(var q = 0; !found && (q < tickVals.length); q++) {\n                    if(\n                        // add 10e6 to eliminate problematic digits\n                        10e6 + tickVals[q].value ===\n                        10e6 + v\n                    ) {\n                        found = true;\n                    }\n                }\n                if(!found) list.push(T);\n            }\n            minorTickVals = list;\n        }\n    }\n\n    if(isPeriod) positionPeriodTicks(tickVals, ax, ax._definedDelta);\n\n    var i;\n    if(ax.rangebreaks) {\n        var flip = ax._id.charAt(0) === 'y';\n\n        var fontSize = 1; // one pixel minimum\n        if(ax.tickmode === 'auto') {\n            fontSize = ax.tickfont ? ax.tickfont.size : 12;\n        }\n\n        var prevL = NaN;\n        for(i = tickVals.length - 1; i > -1; i--) {\n            if(tickVals[i].drop) {\n                tickVals.splice(i, 1);\n                continue;\n            }\n\n            tickVals[i].value = moveOutsideBreak(tickVals[i].value, ax);\n\n            // avoid overlaps\n            var l = ax.c2p(tickVals[i].value);\n            if(flip ?\n                (prevL > l - fontSize) :\n                (prevL < l + fontSize)\n            ) { // ensure one pixel minimum\n                tickVals.splice(axrev ? i + 1 : i, 1);\n            } else {\n                prevL = l;\n            }\n        }\n    }\n\n    // If same angle over a full circle, the last tick vals is a duplicate.\n    // TODO must do something similar for angular date axes.\n    if(isAngular(ax) && Math.abs(rng[1] - rng[0]) === 360) {\n        tickVals.pop();\n    }\n\n    // save the last tick as well as first, so we can\n    // show the exponent only on the last one\n    ax._tmax = (tickVals[tickVals.length - 1] || {}).value;\n\n    // for showing the rest of a date when the main tick label is only the\n    // latter part: ax._prevDateHead holds what we showed most recently.\n    // Start with it cleared and mark that we're in calcTicks (ie calculating a\n    // whole string of these so we should care what the previous date head was!)\n    ax._prevDateHead = '';\n    ax._inCalcTicks = true;\n\n    var lastVisibleHead;\n    var hideLabel = function(tick) {\n        tick.text = '';\n        ax._prevDateHead = lastVisibleHead;\n    };\n\n    tickVals = tickVals.concat(minorTickVals);\n\n    var t, p;\n    for(i = 0; i < tickVals.length; i++) {\n        var _minor = tickVals[i].minor;\n        var _value = tickVals[i].value;\n\n        if(_minor) {\n            minorTicks.push({\n                x: _value,\n                minor: true\n            });\n        } else {\n            lastVisibleHead = ax._prevDateHead;\n\n            t = axes.tickText(\n                ax,\n                _value,\n                false, // hover\n                tickVals[i].simpleLabel // noSuffixPrefix\n            );\n\n            p = tickVals[i].periodX;\n            if(p !== undefined) {\n                t.periodX = p;\n                if(p > maxRange || p < minRange) { // hide label if outside the range\n                    if(p > maxRange) t.periodX = maxRange;\n                    if(p < minRange) t.periodX = minRange;\n\n                    hideLabel(t);\n                }\n            }\n\n            if(tickVals[i].skipLabel) {\n                hideLabel(t);\n            }\n\n            ticksOut.push(t);\n        }\n    }\n    ticksOut = ticksOut.concat(minorTicks);\n\n    ax._inCalcTicks = false;\n\n    if(isPeriod && ticksOut.length) {\n        // drop very first tick that we added to handle period\n        ticksOut[0].noTick = true;\n    }\n\n    return ticksOut;\n};\n\nfunction filterRangeBreaks(ax, ticksOut) {\n    if(ax.rangebreaks) {\n        // remove ticks falling inside rangebreaks\n        ticksOut = ticksOut.filter(function(d) {\n            return ax.maskBreaks(d.x) !== BADNUM;\n        });\n    }\n\n    return ticksOut;\n}\n\nfunction syncTicks(ax) {\n    // get the overlaying axis\n    var baseAxis = ax._mainAxis;\n\n    var ticksOut = [];\n    if(baseAxis._vals) {\n        for(var i = 0; i < baseAxis._vals.length; i++) {\n            // filter vals with noTick flag\n            if(baseAxis._vals[i].noTick) {\n                continue;\n            }\n\n            // get the position of the every tick\n            var pos = baseAxis.l2p(baseAxis._vals[i].x);\n\n            // get the tick for the current axis based on position\n            var vali = ax.p2l(pos);\n            var obj = axes.tickText(ax, vali);\n\n            // assign minor ticks\n            if(baseAxis._vals[i].minor) {\n                obj.minor = true;\n                obj.text = '';\n            }\n\n            ticksOut.push(obj);\n        }\n    }\n\n    ticksOut = filterRangeBreaks(ax, ticksOut);\n\n    return ticksOut;\n}\n\nfunction arrayTicks(ax, majorOnly) {\n    var rng = Lib.simpleMap(ax.range, ax.r2l);\n    var exRng = expandRange(rng);\n    var tickMin = Math.min(exRng[0], exRng[1]);\n    var tickMax = Math.max(exRng[0], exRng[1]);\n\n    // make sure showing ticks doesn't accidentally add new categories\n    // TODO multicategory, if we allow ticktext / tickvals\n    var tickVal2l = ax.type === 'category' ? ax.d2l_noadd : ax.d2l;\n\n    // array ticks on log axes always show the full number\n    // (if no explicit ticktext overrides it)\n    if(ax.type === 'log' && String(ax.dtick).charAt(0) !== 'L') {\n        ax.dtick = 'L' + Math.pow(10, Math.floor(Math.min(ax.range[0], ax.range[1])) - 1);\n    }\n\n    var ticksOut = [];\n    for(var isMinor = 0; isMinor <= 1; isMinor++) {\n        if((majorOnly !== undefined) && ((majorOnly && isMinor) || (majorOnly === false && !isMinor))) continue;\n        if(isMinor && !ax.minor) continue;\n        var vals = !isMinor ? ax.tickvals : ax.minor.tickvals;\n        var text = !isMinor ? ax.ticktext : [];\n        if(!vals) continue;\n\n\n        // without a text array, just format the given values as any other ticks\n        // except with more precision to the numbers\n        if(!Lib.isArrayOrTypedArray(text)) text = [];\n\n        for(var i = 0; i < vals.length; i++) {\n            var vali = tickVal2l(vals[i]);\n            if(vali > tickMin && vali < tickMax) {\n                var obj = text[i] === undefined ?\n                        axes.tickText(ax, vali) :\n                        tickTextObj(ax, vali, String(text[i]));\n\n                if(isMinor) {\n                    obj.minor = true;\n                    obj.text = '';\n                }\n\n                ticksOut.push(obj);\n            }\n        }\n    }\n\n    ticksOut = filterRangeBreaks(ax, ticksOut);\n\n    return ticksOut;\n}\n\nvar roundBase10 = [2, 5, 10];\nvar roundBase24 = [1, 2, 3, 6, 12];\nvar roundBase60 = [1, 2, 5, 10, 15, 30];\n// 2&3 day ticks are weird, but need something btwn 1&7\nvar roundDays = [1, 2, 3, 7, 14];\n// approx. tick positions for log axes, showing all (1) and just 1, 2, 5 (2)\n// these don't have to be exact, just close enough to round to the right value\nvar roundLog1 = [-0.046, 0, 0.301, 0.477, 0.602, 0.699, 0.778, 0.845, 0.903, 0.954, 1];\nvar roundLog2 = [-0.301, 0, 0.301, 0.699, 1];\n// N.B. `thetaunit; 'radians' angular axes must be converted to degrees\nvar roundAngles = [15, 30, 45, 90, 180];\n\nfunction roundDTick(roughDTick, base, roundingSet) {\n    return base * Lib.roundUp(roughDTick / base, roundingSet);\n}\n\n// autoTicks: calculate best guess at pleasant ticks for this axis\n// inputs:\n//      ax - an axis object\n//      roughDTick - rough tick spacing (to be turned into a nice round number)\n// outputs (into ax):\n//   tick0: starting point for ticks (not necessarily on the graph)\n//      usually 0 for numeric (=10^0=1 for log) or jan 1, 2000 for dates\n//   dtick: the actual, nice round tick spacing, usually a little larger than roughDTick\n//      if the ticks are spaced linearly (linear scale, categories,\n//          log with only full powers, date ticks < month),\n//          this will just be a number\n//      months: M#\n//      years: M# where # is 12*number of years\n//      log with linear ticks: L# where # is the linear tick spacing\n//      log showing powers plus some intermediates:\n//          D1 shows all digits, D2 shows 2 and 5\naxes.autoTicks = function(ax, roughDTick, isMinor) {\n    var base;\n\n    function getBase(v) {\n        return Math.pow(v, Math.floor(Math.log(roughDTick) / Math.LN10));\n    }\n\n    if(ax.type === 'date') {\n        ax.tick0 = Lib.dateTick0(ax.calendar, 0);\n\n        // the criteria below are all based on the rough spacing we calculate\n        // being > half of the final unit - so precalculate twice the rough val\n        var roughX2 = 2 * roughDTick;\n\n        if(roughX2 > ONEAVGYEAR) {\n            roughDTick /= ONEAVGYEAR;\n            base = getBase(10);\n            ax.dtick = 'M' + (12 * roundDTick(roughDTick, base, roundBase10));\n        } else if(roughX2 > ONEAVGMONTH) {\n            roughDTick /= ONEAVGMONTH;\n            ax.dtick = 'M' + roundDTick(roughDTick, 1, roundBase24);\n        } else if(roughX2 > ONEDAY) {\n            ax.dtick = roundDTick(roughDTick, ONEDAY, ax._hasDayOfWeekBreaks ? [1, 2, 7, 14] : roundDays);\n            if(!isMinor) {\n                // get week ticks on sunday\n                // this will also move the base tick off 2000-01-01 if dtick is\n                // 2 or 3 days... but that's a weird enough case that we'll ignore it.\n                var tickformat = axes.getTickFormat(ax);\n                var isPeriod = ax.ticklabelmode === 'period';\n                if(isPeriod) ax._rawTick0 = ax.tick0;\n\n                if(/%[uVW]/.test(tickformat)) {\n                    ax.tick0 = Lib.dateTick0(ax.calendar, 2); // Monday\n                } else {\n                    ax.tick0 = Lib.dateTick0(ax.calendar, 1); // Sunday\n                }\n\n                if(isPeriod) ax._dowTick0 = ax.tick0;\n            }\n        } else if(roughX2 > ONEHOUR) {\n            ax.dtick = roundDTick(roughDTick, ONEHOUR, roundBase24);\n        } else if(roughX2 > ONEMIN) {\n            ax.dtick = roundDTick(roughDTick, ONEMIN, roundBase60);\n        } else if(roughX2 > ONESEC) {\n            ax.dtick = roundDTick(roughDTick, ONESEC, roundBase60);\n        } else {\n            // milliseconds\n            base = getBase(10);\n            ax.dtick = roundDTick(roughDTick, base, roundBase10);\n        }\n    } else if(ax.type === 'log') {\n        ax.tick0 = 0;\n        var rng = Lib.simpleMap(ax.range, ax.r2l);\n        if(ax._isMinor) {\n            // Log axes by default get MORE than nTicks based on the metrics below\n            // But for minor ticks we don't want this increase, we already have\n            // the major ticks.\n            roughDTick *= 1.5;\n        }\n        if(roughDTick > 0.7) {\n            // only show powers of 10\n            ax.dtick = Math.ceil(roughDTick);\n        } else if(Math.abs(rng[1] - rng[0]) < 1) {\n            // span is less than one power of 10\n            var nt = 1.5 * Math.abs((rng[1] - rng[0]) / roughDTick);\n\n            // ticks on a linear scale, labeled fully\n            roughDTick = Math.abs(Math.pow(10, rng[1]) -\n                Math.pow(10, rng[0])) / nt;\n            base = getBase(10);\n            ax.dtick = 'L' + roundDTick(roughDTick, base, roundBase10);\n        } else {\n            // include intermediates between powers of 10,\n            // labeled with small digits\n            // ax.dtick = \"D2\" (show 2 and 5) or \"D1\" (show all digits)\n            ax.dtick = (roughDTick > 0.3) ? 'D2' : 'D1';\n        }\n    } else if(ax.type === 'category' || ax.type === 'multicategory') {\n        ax.tick0 = 0;\n        ax.dtick = Math.ceil(Math.max(roughDTick, 1));\n    } else if(isAngular(ax)) {\n        ax.tick0 = 0;\n        base = 1;\n        ax.dtick = roundDTick(roughDTick, base, roundAngles);\n    } else {\n        // auto ticks always start at 0\n        ax.tick0 = 0;\n        base = getBase(10);\n        ax.dtick = roundDTick(roughDTick, base, roundBase10);\n    }\n\n    // prevent infinite loops\n    if(ax.dtick === 0) ax.dtick = 1;\n\n    // TODO: this is from log axis histograms with autorange off\n    if(!isNumeric(ax.dtick) && typeof ax.dtick !== 'string') {\n        var olddtick = ax.dtick;\n        ax.dtick = 1;\n        throw 'ax.dtick error: ' + String(olddtick);\n    }\n};\n\n// after dtick is already known, find tickround = precision\n// to display in tick labels\n//   for numeric ticks, integer # digits after . to round to\n//   for date ticks, the last date part to show (y,m,d,H,M,S)\n//      or an integer # digits past seconds\nfunction autoTickRound(ax) {\n    var dtick = ax.dtick;\n\n    ax._tickexponent = 0;\n    if(!isNumeric(dtick) && typeof dtick !== 'string') {\n        dtick = 1;\n    }\n\n    if(ax.type === 'category' || ax.type === 'multicategory') {\n        ax._tickround = null;\n    }\n    if(ax.type === 'date') {\n        // If tick0 is unusual, give tickround a bit more information\n        // not necessarily *all* the information in tick0 though, if it's really odd\n        // minimal string length for tick0: 'd' is 10, 'M' is 16, 'S' is 19\n        // take off a leading minus (year < 0) and i (intercalary month) so length is consistent\n        var tick0ms = ax.r2l(ax.tick0);\n        var tick0str = ax.l2r(tick0ms).replace(/(^-|i)/g, '');\n        var tick0len = tick0str.length;\n\n        if(String(dtick).charAt(0) === 'M') {\n            // any tick0 more specific than a year: alway show the full date\n            if(tick0len > 10 || tick0str.substr(5) !== '01-01') ax._tickround = 'd';\n            // show the month unless ticks are full multiples of a year\n            else ax._tickround = (+(dtick.substr(1)) % 12 === 0) ? 'y' : 'm';\n        } else if((dtick >= ONEDAY && tick0len <= 10) || (dtick >= ONEDAY * 15)) ax._tickround = 'd';\n        else if((dtick >= ONEMIN && tick0len <= 16) || (dtick >= ONEHOUR)) ax._tickround = 'M';\n        else if((dtick >= ONESEC && tick0len <= 19) || (dtick >= ONEMIN)) ax._tickround = 'S';\n        else {\n            // tickround is a number of digits of fractional seconds\n            // of any two adjacent ticks, at least one will have the maximum fractional digits\n            // of all possible ticks - so take the max. length of tick0 and the next one\n            var tick1len = ax.l2r(tick0ms + dtick).replace(/^-/, '').length;\n            ax._tickround = Math.max(tick0len, tick1len) - 20;\n\n            // We shouldn't get here... but in case there's a situation I'm\n            // not thinking of where tick0str and tick1str are identical or\n            // something, fall back on maximum precision\n            if(ax._tickround < 0) ax._tickround = 4;\n        }\n    } else if(isNumeric(dtick) || dtick.charAt(0) === 'L') {\n        // linear or log (except D1, D2)\n        var rng = ax.range.map(ax.r2d || Number);\n        if(!isNumeric(dtick)) dtick = Number(dtick.substr(1));\n        // 2 digits past largest digit of dtick\n        ax._tickround = 2 - Math.floor(Math.log(dtick) / Math.LN10 + 0.01);\n\n        var maxend = Math.max(Math.abs(rng[0]), Math.abs(rng[1]));\n        var rangeexp = Math.floor(Math.log(maxend) / Math.LN10 + 0.01);\n        var minexponent = ax.minexponent === undefined ? 3 : ax.minexponent;\n        if(Math.abs(rangeexp) > minexponent) {\n            if(isSIFormat(ax.exponentformat) && !beyondSI(rangeexp)) {\n                ax._tickexponent = 3 * Math.round((rangeexp - 1) / 3);\n            } else ax._tickexponent = rangeexp;\n        }\n    } else {\n        // D1 or D2 (log)\n        ax._tickround = null;\n    }\n}\n\n// months and years don't have constant millisecond values\n// (but a year is always 12 months so we only need months)\n// log-scale ticks are also not consistently spaced, except\n// for pure powers of 10\n// numeric ticks always have constant differences, other datetime ticks\n// can all be calculated as constant number of milliseconds\naxes.tickIncrement = function(x, dtick, axrev, calendar) {\n    var axSign = axrev ? -1 : 1;\n\n    // includes linear, all dates smaller than month, and pure 10^n in log\n    if(isNumeric(dtick)) return Lib.increment(x, axSign * dtick);\n\n    // everything else is a string, one character plus a number\n    var tType = dtick.charAt(0);\n    var dtSigned = axSign * Number(dtick.substr(1));\n\n    // Dates: months (or years - see Lib.incrementMonth)\n    if(tType === 'M') return Lib.incrementMonth(x, dtSigned, calendar);\n\n    // Log scales: Linear, Digits\n    if(tType === 'L') return Math.log(Math.pow(10, x) + dtSigned) / Math.LN10;\n\n    // log10 of 2,5,10, or all digits (logs just have to be\n    // close enough to round)\n    if(tType === 'D') {\n        var tickset = (dtick === 'D2') ? roundLog2 : roundLog1;\n        var x2 = x + axSign * 0.01;\n        var frac = Lib.roundUp(Lib.mod(x2, 1), tickset, axrev);\n\n        return Math.floor(x2) +\n            Math.log(d3.round(Math.pow(10, frac), 1)) / Math.LN10;\n    }\n\n    throw 'unrecognized dtick ' + String(dtick);\n};\n\n// calculate the first tick on an axis\naxes.tickFirst = function(ax, opts) {\n    var r2l = ax.r2l || Number;\n    var rng = Lib.simpleMap(ax.range, r2l, undefined, undefined, opts);\n    var axrev = rng[1] < rng[0];\n    var sRound = axrev ? Math.floor : Math.ceil;\n    // add a tiny extra bit to make sure we get ticks\n    // that may have been rounded out\n    var r0 = expandRange(rng)[0];\n    var dtick = ax.dtick;\n    var tick0 = r2l(ax.tick0);\n\n    if(isNumeric(dtick)) {\n        var tmin = sRound((r0 - tick0) / dtick) * dtick + tick0;\n\n        // make sure no ticks outside the category list\n        if(ax.type === 'category' || ax.type === 'multicategory') {\n            tmin = Lib.constrain(tmin, 0, ax._categories.length - 1);\n        }\n        return tmin;\n    }\n\n    var tType = dtick.charAt(0);\n    var dtNum = Number(dtick.substr(1));\n\n    // Dates: months (or years)\n    if(tType === 'M') {\n        var cnt = 0;\n        var t0 = tick0;\n        var t1, mult, newDTick;\n\n        // This algorithm should work for *any* nonlinear (but close to linear!)\n        // tick spacing. Limit to 10 iterations, for gregorian months it's normally <=3.\n        while(cnt < 10) {\n            t1 = axes.tickIncrement(t0, dtick, axrev, ax.calendar);\n            if((t1 - r0) * (t0 - r0) <= 0) {\n                // t1 and t0 are on opposite sides of r0! we've succeeded!\n                if(axrev) return Math.min(t0, t1);\n                return Math.max(t0, t1);\n            }\n            mult = (r0 - ((t0 + t1) / 2)) / (t1 - t0);\n            newDTick = tType + ((Math.abs(Math.round(mult)) || 1) * dtNum);\n            t0 = axes.tickIncrement(t0, newDTick, mult < 0 ? !axrev : axrev, ax.calendar);\n            cnt++;\n        }\n        Lib.error('tickFirst did not converge', ax);\n        return t0;\n    } else if(tType === 'L') {\n        // Log scales: Linear, Digits\n\n        return Math.log(sRound(\n            (Math.pow(10, r0) - tick0) / dtNum) * dtNum + tick0) / Math.LN10;\n    } else if(tType === 'D') {\n        var tickset = (dtick === 'D2') ? roundLog2 : roundLog1;\n        var frac = Lib.roundUp(Lib.mod(r0, 1), tickset, axrev);\n\n        return Math.floor(r0) +\n            Math.log(d3.round(Math.pow(10, frac), 1)) / Math.LN10;\n    } else throw 'unrecognized dtick ' + String(dtick);\n};\n\n// draw the text for one tick.\n// px,py are the location on gd.paper\n// prefix is there so the x axis ticks can be dropped a line\n// ax is the axis layout, x is the tick value\n// hover is a (truthy) flag for whether to show numbers with a bit\n// more precision for hovertext\naxes.tickText = function(ax, x, hover, noSuffixPrefix) {\n    var out = tickTextObj(ax, x);\n    var arrayMode = ax.tickmode === 'array';\n    var extraPrecision = hover || arrayMode;\n    var axType = ax.type;\n    // TODO multicategory, if we allow ticktext / tickvals\n    var tickVal2l = axType === 'category' ? ax.d2l_noadd : ax.d2l;\n    var i;\n\n    if(arrayMode && Lib.isArrayOrTypedArray(ax.ticktext)) {\n        var rng = Lib.simpleMap(ax.range, ax.r2l);\n        var minDiff = (Math.abs(rng[1] - rng[0]) - (ax._lBreaks || 0)) / 10000;\n\n        for(i = 0; i < ax.ticktext.length; i++) {\n            if(Math.abs(x - tickVal2l(ax.tickvals[i])) < minDiff) break;\n        }\n        if(i < ax.ticktext.length) {\n            out.text = String(ax.ticktext[i]);\n            return out;\n        }\n    }\n\n    function isHidden(showAttr) {\n        if(showAttr === undefined) return true;\n        if(hover) return showAttr === 'none';\n\n        var firstOrLast = {\n            first: ax._tmin,\n            last: ax._tmax\n        }[showAttr];\n\n        return showAttr !== 'all' && x !== firstOrLast;\n    }\n\n    var hideexp = hover ?\n        'never' :\n        ax.exponentformat !== 'none' && isHidden(ax.showexponent) ? 'hide' : '';\n\n    if(axType === 'date') formatDate(ax, out, hover, extraPrecision);\n    else if(axType === 'log') formatLog(ax, out, hover, extraPrecision, hideexp);\n    else if(axType === 'category') formatCategory(ax, out);\n    else if(axType === 'multicategory') formatMultiCategory(ax, out, hover);\n    else if(isAngular(ax)) formatAngle(ax, out, hover, extraPrecision, hideexp);\n    else formatLinear(ax, out, hover, extraPrecision, hideexp);\n\n    // add prefix and suffix\n    if(!noSuffixPrefix) {\n        if(ax.tickprefix && !isHidden(ax.showtickprefix)) out.text = ax.tickprefix + out.text;\n        if(ax.ticksuffix && !isHidden(ax.showticksuffix)) out.text += ax.ticksuffix;\n    }\n\n    if(ax.labelalias && ax.labelalias.hasOwnProperty(out.text)) {\n        var t = ax.labelalias[out.text];\n        if(typeof t === 'string') out.text = t;\n    }\n\n    // Setup ticks and grid lines boundaries\n    // at 1/2 a 'category' to the left/bottom\n    if(ax.tickson === 'boundaries' || ax.showdividers) {\n        var inbounds = function(v) {\n            var p = ax.l2p(v);\n            return p >= 0 && p <= ax._length ? v : null;\n        };\n\n        out.xbnd = [\n            inbounds(out.x - 0.5),\n            inbounds(out.x + ax.dtick - 0.5)\n        ];\n    }\n\n    return out;\n};\n\n/**\n * create text for a hover label on this axis, with special handling of\n * log axes (where negative values can't be displayed but can appear in hover text)\n *\n * @param {object} ax: the axis to format text for\n * @param {number or array of numbers} values: calcdata value(s) to format\n * @param {Optional(string)} hoverformat: trace (x|y)hoverformat to override axis.hoverformat\n *\n * @returns {string} `val` formatted as a string appropriate to this axis, or\n *     first value and second value as a range (ie '<val1> - <val2>') if the second value is provided and\n *     it's different from the first value.\n */\naxes.hoverLabelText = function(ax, values, hoverformat) {\n    if(hoverformat) ax = Lib.extendFlat({}, ax, {hoverformat: hoverformat});\n\n    var val = Lib.isArrayOrTypedArray(values) ? values[0] : values;\n    var val2 = Lib.isArrayOrTypedArray(values) ? values[1] : undefined;\n    if(val2 !== undefined && val2 !== val) {\n        return (\n            axes.hoverLabelText(ax, val, hoverformat) + ' - ' +\n            axes.hoverLabelText(ax, val2, hoverformat)\n        );\n    }\n\n    var logOffScale = (ax.type === 'log' && val <= 0);\n    var tx = axes.tickText(ax, ax.c2l(logOffScale ? -val : val), 'hover').text;\n\n    if(logOffScale) {\n        return val === 0 ? '0' : MINUS_SIGN + tx;\n    }\n\n    // TODO: should we do something special if the axis calendar and\n    // the data calendar are different? Somehow display both dates with\n    // their system names? Right now it will just display in the axis calendar\n    // but users could add the other one as text.\n    return tx;\n};\n\nfunction tickTextObj(ax, x, text) {\n    var tf = ax.tickfont || {};\n\n    return {\n        x: x,\n        dx: 0,\n        dy: 0,\n        text: text || '',\n        fontSize: tf.size,\n        font: tf.family,\n        fontColor: tf.color\n    };\n}\n\nfunction formatDate(ax, out, hover, extraPrecision) {\n    var tr = ax._tickround;\n    var fmt = (hover && ax.hoverformat) || axes.getTickFormat(ax);\n\n    // Only apply extra precision if no explicit format was provided.\n    extraPrecision = !fmt && extraPrecision;\n\n    if(extraPrecision) {\n        // second or sub-second precision: extra always shows max digits.\n        // for other fields, extra precision just adds one field.\n        if(isNumeric(tr)) tr = 4;\n        else tr = {y: 'm', m: 'd', d: 'M', M: 'S', S: 4}[tr];\n    }\n\n    var dateStr = Lib.formatDate(out.x, fmt, tr, ax._dateFormat, ax.calendar, ax._extraFormat);\n    var headStr;\n\n    var splitIndex = dateStr.indexOf('\\n');\n    if(splitIndex !== -1) {\n        headStr = dateStr.substr(splitIndex + 1);\n        dateStr = dateStr.substr(0, splitIndex);\n    }\n\n    if(extraPrecision) {\n        // if extraPrecision led to trailing zeros, strip them off\n        // actually, this can lead to removing even more zeros than\n        // in the original rounding, but that's fine because in these\n        // contexts uniformity is not so important (if there's even\n        // anything to be uniform with!)\n\n        // can we remove the whole time part?\n        if(headStr !== undefined && (dateStr === '00:00:00' || dateStr === '00:00')) {\n            dateStr = headStr;\n            headStr = '';\n        } else if(dateStr.length === 8) {\n            // strip off seconds if they're zero (zero fractional seconds\n            // are already omitted)\n            // but we never remove minutes and leave just hours\n            dateStr = dateStr.replace(/:00$/, '');\n        }\n    }\n\n    if(headStr) {\n        if(hover) {\n            // hover puts it all on one line, so headPart works best up front\n            // except for year headPart: turn this into \"Jan 1, 2000\" etc.\n            if(tr === 'd') dateStr += ', ' + headStr;\n            else dateStr = headStr + (dateStr ? ', ' + dateStr : '');\n        } else {\n            if(\n                !ax._inCalcTicks ||\n                ax._prevDateHead !== headStr\n            ) {\n                ax._prevDateHead = headStr;\n                dateStr += '<br>' + headStr;\n            } else {\n                var isInside = insideTicklabelposition(ax);\n                var side = ax._trueSide || ax.side; // polar mocks the side of the radial axis\n                if(\n                    (!isInside && side === 'top') ||\n                    (isInside && side === 'bottom')\n                ) {\n                    dateStr += '<br> ';\n                }\n            }\n        }\n    }\n\n    out.text = dateStr;\n}\n\nfunction formatLog(ax, out, hover, extraPrecision, hideexp) {\n    var dtick = ax.dtick;\n    var x = out.x;\n    var tickformat = ax.tickformat;\n    var dtChar0 = typeof dtick === 'string' && dtick.charAt(0);\n\n    if(hideexp === 'never') {\n        // If this is a hover label, then we must *never* hide the exponent\n        // for the sake of display, which could give the wrong value by\n        // potentially many orders of magnitude. If hideexp was 'never', then\n        // it's now succeeded by preventing the other condition from automating\n        // this choice. Thus we can unset it so that the axis formatting takes\n        // precedence.\n        hideexp = '';\n    }\n\n    if(extraPrecision && (dtChar0 !== 'L')) {\n        dtick = 'L3';\n        dtChar0 = 'L';\n    }\n\n    if(tickformat || (dtChar0 === 'L')) {\n        out.text = numFormat(Math.pow(10, x), ax, hideexp, extraPrecision);\n    } else if(isNumeric(dtick) || ((dtChar0 === 'D') && (Lib.mod(x + 0.01, 1) < 0.1))) {\n        var p = Math.round(x);\n        var absP = Math.abs(p);\n        var exponentFormat = ax.exponentformat;\n        if(exponentFormat === 'power' || (isSIFormat(exponentFormat) && beyondSI(p))) {\n            if(p === 0) out.text = 1;\n            else if(p === 1) out.text = '10';\n            else out.text = '10<sup>' + (p > 1 ? '' : MINUS_SIGN) + absP + '</sup>';\n\n            out.fontSize *= 1.25;\n        } else if((exponentFormat === 'e' || exponentFormat === 'E') && absP > 2) {\n            out.text = '1' + exponentFormat + (p > 0 ? '+' : MINUS_SIGN) + absP;\n        } else {\n            out.text = numFormat(Math.pow(10, x), ax, '', 'fakehover');\n            if(dtick === 'D1' && ax._id.charAt(0) === 'y') {\n                out.dy -= out.fontSize / 6;\n            }\n        }\n    } else if(dtChar0 === 'D') {\n        out.text = String(Math.round(Math.pow(10, Lib.mod(x, 1))));\n        out.fontSize *= 0.75;\n    } else throw 'unrecognized dtick ' + String(dtick);\n\n    // if 9's are printed on log scale, move the 10's away a bit\n    if(ax.dtick === 'D1') {\n        var firstChar = String(out.text).charAt(0);\n        if(firstChar === '0' || firstChar === '1') {\n            if(ax._id.charAt(0) === 'y') {\n                out.dx -= out.fontSize / 4;\n            } else {\n                out.dy += out.fontSize / 2;\n                out.dx += (ax.range[1] > ax.range[0] ? 1 : -1) *\n                    out.fontSize * (x < 0 ? 0.5 : 0.25);\n            }\n        }\n    }\n}\n\nfunction formatCategory(ax, out) {\n    var tt = ax._categories[Math.round(out.x)];\n    if(tt === undefined) tt = '';\n    out.text = String(tt);\n}\n\nfunction formatMultiCategory(ax, out, hover) {\n    var v = Math.round(out.x);\n    var cats = ax._categories[v] || [];\n    var tt = cats[1] === undefined ? '' : String(cats[1]);\n    var tt2 = cats[0] === undefined ? '' : String(cats[0]);\n\n    if(hover) {\n        // TODO is this what we want?\n        out.text = tt2 + ' - ' + tt;\n    } else {\n        // setup for secondary labels\n        out.text = tt;\n        out.text2 = tt2;\n    }\n}\n\nfunction formatLinear(ax, out, hover, extraPrecision, hideexp) {\n    if(hideexp === 'never') {\n        // If this is a hover label, then we must *never* hide the exponent\n        // for the sake of display, which could give the wrong value by\n        // potentially many orders of magnitude. If hideexp was 'never', then\n        // it's now succeeded by preventing the other condition from automating\n        // this choice. Thus we can unset it so that the axis formatting takes\n        // precedence.\n        hideexp = '';\n    } else if(ax.showexponent === 'all' && Math.abs(out.x / ax.dtick) < 1e-6) {\n        // don't add an exponent to zero if we're showing all exponents\n        // so the only reason you'd show an exponent on zero is if it's the\n        // ONLY tick to get an exponent (first or last)\n        hideexp = 'hide';\n    }\n    out.text = numFormat(out.x, ax, hideexp, extraPrecision);\n}\n\nfunction formatAngle(ax, out, hover, extraPrecision, hideexp) {\n    if(ax.thetaunit === 'radians' && !hover) {\n        var num = out.x / 180;\n\n        if(num === 0) {\n            out.text = '0';\n        } else {\n            var frac = num2frac(num);\n\n            if(frac[1] >= 100) {\n                out.text = numFormat(Lib.deg2rad(out.x), ax, hideexp, extraPrecision);\n            } else {\n                var isNeg = out.x < 0;\n\n                if(frac[1] === 1) {\n                    if(frac[0] === 1) out.text = 'π';\n                    else out.text = frac[0] + 'π';\n                } else {\n                    out.text = [\n                        '<sup>', frac[0], '</sup>',\n                        '⁄',\n                        '<sub>', frac[1], '</sub>',\n                        'π'\n                    ].join('');\n                }\n\n                if(isNeg) out.text = MINUS_SIGN + out.text;\n            }\n        }\n    } else {\n        out.text = numFormat(out.x, ax, hideexp, extraPrecision);\n    }\n}\n\n// inspired by\n// https://github.com/yisibl/num2fraction/blob/master/index.js\nfunction num2frac(num) {\n    function almostEq(a, b) {\n        return Math.abs(a - b) <= 1e-6;\n    }\n\n    function findGCD(a, b) {\n        return almostEq(b, 0) ? a : findGCD(b, a % b);\n    }\n\n    function findPrecision(n) {\n        var e = 1;\n        while(!almostEq(Math.round(n * e) / e, n)) {\n            e *= 10;\n        }\n        return e;\n    }\n\n    var precision = findPrecision(num);\n    var number = num * precision;\n    var gcd = Math.abs(findGCD(number, precision));\n\n    return [\n        // numerator\n        Math.round(number / gcd),\n        // denominator\n        Math.round(precision / gcd)\n    ];\n}\n\n// format a number (tick value) according to the axis settings\n// new, more reliable procedure than d3.round or similar:\n// add half the rounding increment, then stringify and truncate\n// also automatically switch to sci. notation\nvar SIPREFIXES = ['f', 'p', 'n', 'μ', 'm', '', 'k', 'M', 'G', 'T'];\n\nfunction isSIFormat(exponentFormat) {\n    return exponentFormat === 'SI' || exponentFormat === 'B';\n}\n\n// are we beyond the range of common SI prefixes?\n// 10^-16 -> 1x10^-16\n// 10^-15 -> 1f\n// ...\n// 10^14 -> 100T\n// 10^15 -> 1x10^15\n// 10^16 -> 1x10^16\nfunction beyondSI(exponent) {\n    return exponent > 14 || exponent < -15;\n}\n\nfunction numFormat(v, ax, fmtoverride, hover) {\n    var isNeg = v < 0;\n    // max number of digits past decimal point to show\n    var tickRound = ax._tickround;\n    var exponentFormat = fmtoverride || ax.exponentformat || 'B';\n    var exponent = ax._tickexponent;\n    var tickformat = axes.getTickFormat(ax);\n    var separatethousands = ax.separatethousands;\n\n    // special case for hover: set exponent just for this value, and\n    // add a couple more digits of precision over tick labels\n    if(hover) {\n        // make a dummy axis obj to get the auto rounding and exponent\n        var ah = {\n            exponentformat: exponentFormat,\n            minexponent: ax.minexponent,\n            dtick: ax.showexponent === 'none' ? ax.dtick :\n                (isNumeric(v) ? Math.abs(v) || 1 : 1),\n            // if not showing any exponents, don't change the exponent\n            // from what we calculate\n            range: ax.showexponent === 'none' ? ax.range.map(ax.r2d) : [0, v || 1]\n        };\n        autoTickRound(ah);\n        tickRound = (Number(ah._tickround) || 0) + 4;\n        exponent = ah._tickexponent;\n        if(ax.hoverformat) tickformat = ax.hoverformat;\n    }\n\n    if(tickformat) return ax._numFormat(tickformat)(v).replace(/-/g, MINUS_SIGN);\n\n    // 'epsilon' - rounding increment\n    var e = Math.pow(10, -tickRound) / 2;\n\n    // exponentFormat codes:\n    // 'e' (1.2e+6, default)\n    // 'E' (1.2E+6)\n    // 'SI' (1.2M)\n    // 'B' (same as SI except 10^9=B not G)\n    // 'none' (1200000)\n    // 'power' (1.2x10^6)\n    // 'hide' (1.2, use 3rd argument=='hide' to eg\n    //      only show exponent on last tick)\n    if(exponentFormat === 'none') exponent = 0;\n\n    // take the sign out, put it back manually at the end\n    // - makes cases easier\n    v = Math.abs(v);\n    if(v < e) {\n        // 0 is just 0, but may get exponent if it's the last tick\n        v = '0';\n        isNeg = false;\n    } else {\n        v += e;\n        // take out a common exponent, if any\n        if(exponent) {\n            v *= Math.pow(10, -exponent);\n            tickRound += exponent;\n        }\n        // round the mantissa\n        if(tickRound === 0) v = String(Math.floor(v));\n        else if(tickRound < 0) {\n            v = String(Math.round(v));\n            v = v.substr(0, v.length + tickRound);\n            for(var i = tickRound; i < 0; i++) v += '0';\n        } else {\n            v = String(v);\n            var dp = v.indexOf('.') + 1;\n            if(dp) v = v.substr(0, dp + tickRound).replace(/\\.?0+$/, '');\n        }\n        // insert appropriate decimal point and thousands separator\n        v = Lib.numSeparate(v, ax._separators, separatethousands);\n    }\n\n    // add exponent\n    if(exponent && exponentFormat !== 'hide') {\n        if(isSIFormat(exponentFormat) && beyondSI(exponent)) exponentFormat = 'power';\n\n        var signedExponent;\n        if(exponent < 0) signedExponent = MINUS_SIGN + -exponent;\n        else if(exponentFormat !== 'power') signedExponent = '+' + exponent;\n        else signedExponent = String(exponent);\n\n        if(exponentFormat === 'e' || exponentFormat === 'E') {\n            v += exponentFormat + signedExponent;\n        } else if(exponentFormat === 'power') {\n            v += '×10<sup>' + signedExponent + '</sup>';\n        } else if(exponentFormat === 'B' && exponent === 9) {\n            v += 'B';\n        } else if(isSIFormat(exponentFormat)) {\n            v += SIPREFIXES[exponent / 3 + 5];\n        }\n    }\n\n    // put sign back in and return\n    // replace standard minus character (which is technically a hyphen)\n    // with a true minus sign\n    if(isNeg) return MINUS_SIGN + v;\n    return v;\n}\n\naxes.getTickFormat = function(ax) {\n    var i;\n\n    function convertToMs(dtick) {\n        return typeof dtick !== 'string' ? dtick : Number(dtick.replace('M', '')) * ONEAVGMONTH;\n    }\n\n    function compareLogTicks(left, right) {\n        var priority = ['L', 'D'];\n        if(typeof left === typeof right) {\n            if(typeof left === 'number') {\n                return left - right;\n            } else {\n                var leftPriority = priority.indexOf(left.charAt(0));\n                var rightPriority = priority.indexOf(right.charAt(0));\n                if(leftPriority === rightPriority) {\n                    return Number(left.replace(/(L|D)/g, '')) - Number(right.replace(/(L|D)/g, ''));\n                } else {\n                    return leftPriority - rightPriority;\n                }\n            }\n        } else {\n            return typeof left === 'number' ? 1 : -1;\n        }\n    }\n\n    function isProperStop(dtick, range, convert) {\n        var convertFn = convert || function(x) { return x;};\n        var leftDtick = range[0];\n        var rightDtick = range[1];\n        return ((!leftDtick && typeof leftDtick !== 'number') || convertFn(leftDtick) <= convertFn(dtick)) &&\n               ((!rightDtick && typeof rightDtick !== 'number') || convertFn(rightDtick) >= convertFn(dtick));\n    }\n\n    function isProperLogStop(dtick, range) {\n        var isLeftDtickNull = range[0] === null;\n        var isRightDtickNull = range[1] === null;\n        var isDtickInRangeLeft = compareLogTicks(dtick, range[0]) >= 0;\n        var isDtickInRangeRight = compareLogTicks(dtick, range[1]) <= 0;\n        return (isLeftDtickNull || isDtickInRangeLeft) && (isRightDtickNull || isDtickInRangeRight);\n    }\n\n    var tickstop, stopi;\n    if(ax.tickformatstops && ax.tickformatstops.length > 0) {\n        switch(ax.type) {\n            case 'date':\n            case 'linear': {\n                for(i = 0; i < ax.tickformatstops.length; i++) {\n                    stopi = ax.tickformatstops[i];\n                    if(stopi.enabled && isProperStop(ax.dtick, stopi.dtickrange, convertToMs)) {\n                        tickstop = stopi;\n                        break;\n                    }\n                }\n                break;\n            }\n            case 'log': {\n                for(i = 0; i < ax.tickformatstops.length; i++) {\n                    stopi = ax.tickformatstops[i];\n                    if(stopi.enabled && isProperLogStop(ax.dtick, stopi.dtickrange)) {\n                        tickstop = stopi;\n                        break;\n                    }\n                }\n                break;\n            }\n            default:\n        }\n    }\n    return tickstop ? tickstop.value : ax.tickformat;\n};\n\n// getSubplots - extract all subplot IDs we need\n// as an array of items like 'xy', 'x2y', 'x2y2'...\n// sorted by x (x,x2,x3...) then y\n// optionally restrict to only subplots containing axis object ax\n//\n// NOTE: this is currently only used OUTSIDE plotly.js (toolpanel, webapp)\n// ideally we get rid of it there (or just copy this there) and remove it here\naxes.getSubplots = function(gd, ax) {\n    var subplotObj = gd._fullLayout._subplots;\n    var allSubplots = subplotObj.cartesian.concat(subplotObj.gl2d || []);\n\n    var out = ax ? axes.findSubplotsWithAxis(allSubplots, ax) : allSubplots;\n\n    out.sort(function(a, b) {\n        var aParts = a.substr(1).split('y');\n        var bParts = b.substr(1).split('y');\n\n        if(aParts[0] === bParts[0]) return +aParts[1] - +bParts[1];\n        return +aParts[0] - +bParts[0];\n    });\n\n    return out;\n};\n\n// find all subplots with axis 'ax'\n// NOTE: this is only used in axes.getSubplots (only used outside plotly.js) and\n// gl2d/convert (where it restricts axis subplots to only those with gl2d)\naxes.findSubplotsWithAxis = function(subplots, ax) {\n    var axMatch = new RegExp(\n        (ax._id.charAt(0) === 'x') ? ('^' + ax._id + 'y') : (ax._id + '$')\n    );\n    var subplotsWithAx = [];\n\n    for(var i = 0; i < subplots.length; i++) {\n        var sp = subplots[i];\n        if(axMatch.test(sp)) subplotsWithAx.push(sp);\n    }\n\n    return subplotsWithAx;\n};\n\n// makeClipPaths: prepare clipPaths for all single axes and all possible xy pairings\naxes.makeClipPaths = function(gd) {\n    var fullLayout = gd._fullLayout;\n\n    // for more info: https://github.com/plotly/plotly.js/issues/2595\n    if(fullLayout._hasOnlyLargeSploms) return;\n\n    var fullWidth = {_offset: 0, _length: fullLayout.width, _id: ''};\n    var fullHeight = {_offset: 0, _length: fullLayout.height, _id: ''};\n    var xaList = axes.list(gd, 'x', true);\n    var yaList = axes.list(gd, 'y', true);\n    var clipList = [];\n    var i, j;\n\n    for(i = 0; i < xaList.length; i++) {\n        clipList.push({x: xaList[i], y: fullHeight});\n        for(j = 0; j < yaList.length; j++) {\n            if(i === 0) clipList.push({x: fullWidth, y: yaList[j]});\n            clipList.push({x: xaList[i], y: yaList[j]});\n        }\n    }\n\n    // selectors don't work right with camelCase tags,\n    // have to use class instead\n    // https://groups.google.com/forum/#!topic/d3-js/6EpAzQ2gU9I\n    var axClips = fullLayout._clips.selectAll('.axesclip')\n        .data(clipList, function(d) { return d.x._id + d.y._id; });\n\n    axClips.enter().append('clipPath')\n        .classed('axesclip', true)\n        .attr('id', function(d) { return 'clip' + fullLayout._uid + d.x._id + d.y._id; })\n      .append('rect');\n\n    axClips.exit().remove();\n\n    axClips.each(function(d) {\n        d3.select(this).select('rect').attr({\n            x: d.x._offset || 0,\n            y: d.y._offset || 0,\n            width: d.x._length || 1,\n            height: d.y._length || 1\n        });\n    });\n};\n\n/**\n * Main multi-axis drawing routine!\n *\n * @param {DOM element} gd : graph div\n * @param {string or array of strings} arg : polymorphic argument\n * @param {object} opts:\n * - @param {boolean} skipTitle : optional flag to skip axis title draw/update\n *\n * Signature 1: Axes.draw(gd, 'redraw')\n *   use this to clear and redraw all axes on graph\n *\n * Signature 2: Axes.draw(gd, '')\n *   use this to draw all axes on graph w/o the selectAll().remove()\n *   of the 'redraw' signature\n *\n * Signature 3: Axes.draw(gd, [axId, axId2, ...])\n *   where the items are axis id string,\n *   use this to update multiple axes in one call\n *\n * N.B draw updates:\n * - ax._r (stored range for use by zoom/pan)\n * - ax._rl (stored linearized range for use by zoom/pan)\n */\naxes.draw = function(gd, arg, opts) {\n    var fullLayout = gd._fullLayout;\n\n    if(arg === 'redraw') {\n        fullLayout._paper.selectAll('g.subplot').each(function(d) {\n            var id = d[0];\n            var plotinfo = fullLayout._plots[id];\n            if(plotinfo) {\n                var xa = plotinfo.xaxis;\n                var ya = plotinfo.yaxis;\n\n                plotinfo.xaxislayer.selectAll('.' + xa._id + 'tick').remove();\n                plotinfo.yaxislayer.selectAll('.' + ya._id + 'tick').remove();\n                plotinfo.xaxislayer.selectAll('.' + xa._id + 'tick2').remove();\n                plotinfo.yaxislayer.selectAll('.' + ya._id + 'tick2').remove();\n                plotinfo.xaxislayer.selectAll('.' + xa._id + 'divider').remove();\n                plotinfo.yaxislayer.selectAll('.' + ya._id + 'divider').remove();\n\n                if(plotinfo.minorGridlayer) plotinfo.minorGridlayer.selectAll('path').remove();\n                if(plotinfo.gridlayer) plotinfo.gridlayer.selectAll('path').remove();\n                if(plotinfo.zerolinelayer) plotinfo.zerolinelayer.selectAll('path').remove();\n\n                fullLayout._infolayer.select('.g-' + xa._id + 'title').remove();\n                fullLayout._infolayer.select('.g-' + ya._id + 'title').remove();\n            }\n        });\n    }\n\n    var axList = (!arg || arg === 'redraw') ? axes.listIds(gd) : arg;\n\n    var fullAxList = axes.list(gd);\n    // Get the list of the overlaying axis for all 'shift' axes\n    var overlayingShiftedAx = fullAxList.filter(function(ax) {\n        return ax.autoshift;\n    }).map(function(ax) {\n        return ax.overlaying;\n    });\n\n    // order axes that have dependency to other axes\n    axList.map(function(axId) {\n        var ax = axes.getFromId(gd, axId);\n\n        if(ax.tickmode === 'sync' && ax.overlaying) {\n            var overlayingIndex = axList.findIndex(function(axis) {return axis === ax.overlaying;});\n\n            if(overlayingIndex >= 0) {\n                axList.unshift(axList.splice(overlayingIndex, 1).shift());\n            }\n        }\n    });\n\n    var axShifts = {false: {left: 0, right: 0}};\n\n    return Lib.syncOrAsync(axList.map(function(axId) {\n        return function() {\n            if(!axId) return;\n\n            var ax = axes.getFromId(gd, axId);\n\n            if(!opts) opts = {};\n            opts.axShifts = axShifts;\n            opts.overlayingShiftedAx = overlayingShiftedAx;\n\n            var axDone = axes.drawOne(gd, ax, opts);\n\n            if(ax._shiftPusher) {\n                incrementShift(ax, ax._fullDepth || 0, axShifts, true);\n            }\n            ax._r = ax.range.slice();\n            ax._rl = Lib.simpleMap(ax._r, ax.r2l);\n\n            return axDone;\n        };\n    }));\n};\n\n/**\n * Draw one cartesian axis\n *\n * @param {DOM element} gd\n * @param {object} ax (full) axis object\n * @param {object} opts\n * - @param {boolean} skipTitle (set to true to skip axis title draw call)\n *\n * Depends on:\n * - ax._mainSubplot (from linkSubplots)\n * - ax._mainAxis\n * - ax._anchorAxis\n * - ax._subplotsWith\n * - ax._counterDomainMin, ax._counterDomainMax (optionally, from linkSubplots)\n * - ax._tickAngles (on redraw only, old value relinked during supplyDefaults)\n * - ax._mainLinePosition (from lsInner)\n * - ax._mainMirrorPosition\n * - ax._linepositions\n *\n * Fills in:\n * - ax._vals:\n * - ax._gridVals:\n * - ax._selections:\n * - ax._tickAngles:\n * - ax._depth (when required only):\n * - and calls ax.setScale\n */\naxes.drawOne = function(gd, ax, opts) {\n    opts = opts || {};\n\n    var axShifts = opts.axShifts || {};\n    var overlayingShiftedAx = opts.overlayingShiftedAx || [];\n\n    var i, sp, plotinfo;\n\n    ax.setScale();\n\n    var fullLayout = gd._fullLayout;\n    var axId = ax._id;\n    var axLetter = axId.charAt(0);\n    var counterLetter = axes.counterLetter(axId);\n    var mainPlotinfo = fullLayout._plots[ax._mainSubplot];\n\n    // this happens when updating matched group with 'missing' axes\n    if(!mainPlotinfo) return;\n\n    ax._shiftPusher = ax.autoshift ||\n        overlayingShiftedAx.indexOf(ax._id) !== -1 ||\n        overlayingShiftedAx.indexOf(ax.overlaying) !== -1;\n    // An axis is also shifted by 1/2 of its own linewidth and inside tick length if applicable\n    // as well as its manually specified `shift` val if we're in the context of `autoshift`\n    if(ax._shiftPusher & ax.anchor === 'free') {\n        var selfPush = (ax.linewidth / 2 || 0);\n        if(ax.ticks === 'inside') {\n            selfPush += ax.ticklen;\n        }\n        incrementShift(ax, selfPush, axShifts, true);\n        incrementShift(ax, (ax.shift || 0), axShifts, false);\n    }\n\n    // Somewhat inelegant way of making sure that the shift value is only updated when the\n    // Axes.DrawOne() function is called from the right context. An issue when redrawing the\n    // axis as result of using the dragbox, for example.\n    if(opts.skipTitle !== true || ax._shift === undefined) ax._shift = setShiftVal(ax, axShifts);\n\n    var mainAxLayer = mainPlotinfo[axLetter + 'axislayer'];\n    var mainLinePosition = ax._mainLinePosition;\n    var mainLinePositionShift = mainLinePosition += ax._shift;\n    var mainMirrorPosition = ax._mainMirrorPosition;\n\n    var vals = ax._vals = axes.calcTicks(ax);\n\n    // Add a couple of axis properties that should cause us to recreate\n    // elements. Used in d3 data function.\n    var axInfo = [ax.mirror, mainLinePositionShift, mainMirrorPosition].join('_');\n    for(i = 0; i < vals.length; i++) {\n        vals[i].axInfo = axInfo;\n    }\n\n    // stash selections to avoid DOM queries e.g.\n    // - stash tickLabels selection, so that drawTitle can use it to scoot title\n    ax._selections = {};\n    // stash tick angle (including the computed 'auto' values) per tick-label class\n    // linkup 'previous' tick angles on redraws\n    if(ax._tickAngles) ax._prevTickAngles = ax._tickAngles;\n    ax._tickAngles = {};\n    // measure [in px] between axis position and outward-most part of bounding box\n    // (touching either the tick label or ticks)\n    // depth can be expansive to compute, so we only do so when required\n    ax._depth = null;\n\n    // calcLabelLevelBbox can be expensive,\n    // so make sure to not call it twice during the same Axes.drawOne call\n    // by stashing label-level bounding boxes per tick-label class\n    var llbboxes = {};\n    function getLabelLevelBbox(suffix) {\n        var cls = axId + (suffix || 'tick');\n        if(!llbboxes[cls]) llbboxes[cls] = calcLabelLevelBbox(ax, cls);\n        return llbboxes[cls];\n    }\n\n    if(!ax.visible) return;\n\n    var transTickFn = axes.makeTransTickFn(ax);\n    var transTickLabelFn = axes.makeTransTickLabelFn(ax);\n\n    var tickVals;\n    // We remove zero lines, grid lines, and inside ticks if they're within 1px of the end\n    // The key case here is removing zero lines when the axis bound is zero\n    var valsClipped;\n\n    var insideTicks = ax.ticks === 'inside';\n    var outsideTicks = ax.ticks === 'outside';\n\n    if(ax.tickson === 'boundaries') {\n        var boundaryVals = getBoundaryVals(ax, vals);\n        valsClipped = axes.clipEnds(ax, boundaryVals);\n        tickVals = insideTicks ? valsClipped : boundaryVals;\n    } else {\n        valsClipped = axes.clipEnds(ax, vals);\n        tickVals = (insideTicks && ax.ticklabelmode !== 'period') ? valsClipped : vals;\n    }\n\n    var gridVals = ax._gridVals = valsClipped;\n    var dividerVals = getDividerVals(ax, vals);\n\n    if(!fullLayout._hasOnlyLargeSploms) {\n        var subplotsWithAx = ax._subplotsWith;\n\n        // keep track of which subplots (by main counter axis) we've already\n        // drawn grids for, so we don't overdraw overlaying subplots\n        var finishedGrids = {};\n\n        for(i = 0; i < subplotsWithAx.length; i++) {\n            sp = subplotsWithAx[i];\n            plotinfo = fullLayout._plots[sp];\n\n            var counterAxis = plotinfo[counterLetter + 'axis'];\n            var mainCounterID = counterAxis._mainAxis._id;\n            if(finishedGrids[mainCounterID]) continue;\n            finishedGrids[mainCounterID] = 1;\n\n            var gridPath = axLetter === 'x' ?\n                'M0,' + counterAxis._offset + 'v' + counterAxis._length :\n                'M' + counterAxis._offset + ',0h' + counterAxis._length;\n\n            axes.drawGrid(gd, ax, {\n                vals: gridVals,\n                counterAxis: counterAxis,\n                layer: plotinfo.gridlayer.select('.' + axId),\n                minorLayer: plotinfo.minorGridlayer.select('.' + axId),\n                path: gridPath,\n                transFn: transTickFn\n            });\n            axes.drawZeroLine(gd, ax, {\n                counterAxis: counterAxis,\n                layer: plotinfo.zerolinelayer,\n                path: gridPath,\n                transFn: transTickFn\n            });\n        }\n    }\n\n    var tickPath;\n\n    var majorTickSigns = axes.getTickSigns(ax);\n    var minorTickSigns = axes.getTickSigns(ax, 'minor');\n\n    if(ax.ticks || (ax.minor && ax.minor.ticks)) {\n        var majorTickPath = axes.makeTickPath(ax, mainLinePositionShift, majorTickSigns[2]);\n        var minorTickPath = axes.makeTickPath(ax, mainLinePositionShift, minorTickSigns[2], { minor: true });\n\n        var mirrorMajorTickPath;\n        var mirrorMinorTickPath;\n\n        var fullMajorTickPath;\n        var fullMinorTickPath;\n\n        if(ax._anchorAxis && ax.mirror && ax.mirror !== true) {\n            mirrorMajorTickPath = axes.makeTickPath(ax, mainMirrorPosition, majorTickSigns[3]);\n            mirrorMinorTickPath = axes.makeTickPath(ax, mainMirrorPosition, minorTickSigns[3], { minor: true });\n\n            fullMajorTickPath = majorTickPath + mirrorMajorTickPath;\n            fullMinorTickPath = minorTickPath + mirrorMinorTickPath;\n        } else {\n            mirrorMajorTickPath = '';\n            mirrorMinorTickPath = '';\n            fullMajorTickPath = majorTickPath;\n            fullMinorTickPath = minorTickPath;\n        }\n\n        if(ax.showdividers && outsideTicks && ax.tickson === 'boundaries') {\n            var dividerLookup = {};\n            for(i = 0; i < dividerVals.length; i++) {\n                dividerLookup[dividerVals[i].x] = 1;\n            }\n            tickPath = function(d) {\n                return dividerLookup[d.x] ? mirrorMajorTickPath : fullMajorTickPath;\n            };\n        } else {\n            tickPath = function(d) {\n                return d.minor ? fullMinorTickPath : fullMajorTickPath;\n            };\n        }\n    }\n\n    axes.drawTicks(gd, ax, {\n        vals: tickVals,\n        layer: mainAxLayer,\n        path: tickPath,\n        transFn: transTickFn\n    });\n\n    if(ax.mirror === 'allticks') {\n        var tickSubplots = Object.keys(ax._linepositions || {});\n\n        for(i = 0; i < tickSubplots.length; i++) {\n            sp = tickSubplots[i];\n            plotinfo = fullLayout._plots[sp];\n            // [bottom or left, top or right], free and main are handled above\n            var linepositions = ax._linepositions[sp] || [];\n\n            var p0 = linepositions[0];\n            var p1 = linepositions[1];\n            var isMinor = linepositions[2];\n\n            var spTickPath =\n                axes.makeTickPath(ax, p0,\n                    isMinor ? majorTickSigns[0] : minorTickSigns[0],\n                    { minor: isMinor }\n                ) +\n                axes.makeTickPath(ax, p1,\n                    isMinor ? majorTickSigns[1] : minorTickSigns[1],\n                    { minor: isMinor }\n                );\n\n            axes.drawTicks(gd, ax, {\n                vals: tickVals,\n                layer: plotinfo[axLetter + 'axislayer'],\n                path: spTickPath,\n                transFn: transTickFn\n            });\n        }\n    }\n\n    var seq = [];\n\n    // tick labels - for now just the main labels.\n    // TODO: mirror labels, esp for subplots\n\n    seq.push(function() {\n        return axes.drawLabels(gd, ax, {\n            vals: vals,\n            layer: mainAxLayer,\n            plotinfo: plotinfo,\n            transFn: transTickLabelFn,\n            labelFns: axes.makeLabelFns(ax, mainLinePositionShift)\n        });\n    });\n\n    if(ax.type === 'multicategory') {\n        var pad = {x: 2, y: 10}[axLetter];\n\n        seq.push(function() {\n            var bboxKey = {x: 'height', y: 'width'}[axLetter];\n            var standoff = getLabelLevelBbox()[bboxKey] + pad +\n                (ax._tickAngles[axId + 'tick'] ? ax.tickfont.size * LINE_SPACING : 0);\n\n            return axes.drawLabels(gd, ax, {\n                vals: getSecondaryLabelVals(ax, vals),\n                layer: mainAxLayer,\n                cls: axId + 'tick2',\n                repositionOnUpdate: true,\n                secondary: true,\n                transFn: transTickFn,\n                labelFns: axes.makeLabelFns(ax, mainLinePositionShift + standoff * majorTickSigns[4])\n            });\n        });\n\n        seq.push(function() {\n            ax._depth = majorTickSigns[4] * (getLabelLevelBbox('tick2')[ax.side] - mainLinePositionShift);\n\n            return drawDividers(gd, ax, {\n                vals: dividerVals,\n                layer: mainAxLayer,\n                path: axes.makeTickPath(ax, mainLinePositionShift, majorTickSigns[4], { len: ax._depth }),\n                transFn: transTickFn\n            });\n        });\n    } else if(ax.title.hasOwnProperty('standoff')) {\n        seq.push(function() {\n            ax._depth = majorTickSigns[4] * (getLabelLevelBbox()[ax.side] - mainLinePositionShift);\n        });\n    }\n\n    var hasRangeSlider = Registry.getComponentMethod('rangeslider', 'isVisible')(ax);\n\n    if(!opts.skipTitle &&\n        !(hasRangeSlider && ax.side === 'bottom')\n    ) {\n        seq.push(function() { return drawTitle(gd, ax); });\n    }\n\n    seq.push(function() {\n        var s = ax.side.charAt(0);\n        var sMirror = OPPOSITE_SIDE[ax.side].charAt(0);\n        var pos = axes.getPxPosition(gd, ax);\n        var outsideTickLen = outsideTicks ? ax.ticklen : 0;\n        var llbbox;\n\n        var push;\n        var mirrorPush;\n        var rangeSliderPush;\n\n        if(ax.automargin || hasRangeSlider || ax._shiftPusher) {\n            if(ax.type === 'multicategory') {\n                llbbox = getLabelLevelBbox('tick2');\n            } else {\n                llbbox = getLabelLevelBbox();\n                if(axLetter === 'x' && s === 'b') {\n                    ax._depth = Math.max(llbbox.width > 0 ? llbbox.bottom - pos : 0, outsideTickLen);\n                }\n            }\n        }\n\n        var axDepth = 0;\n        var titleDepth = 0;\n        if(ax._shiftPusher) {\n            axDepth = Math.max(\n                outsideTickLen,\n                llbbox.height > 0 ? (s === 'l' ? pos - llbbox.left : llbbox.right - pos) : 0\n            );\n            if(ax.title.text !== fullLayout._dfltTitle[axLetter]) {\n                titleDepth = (ax._titleStandoff || 0) + (ax._titleScoot || 0);\n                if(s === 'l') {\n                    titleDepth += approxTitleDepth(ax);\n                }\n            }\n\n            ax._fullDepth = Math.max(axDepth, titleDepth);\n        }\n\n        if(ax.automargin) {\n            push = {x: 0, y: 0, r: 0, l: 0, t: 0, b: 0};\n            var domainIndices = [0, 1];\n            var shift = typeof ax._shift === 'number' ? ax._shift : 0;\n            if(axLetter === 'x') {\n                if(s === 'b') {\n                    push[s] = ax._depth;\n                } else {\n                    push[s] = ax._depth = Math.max(llbbox.width > 0 ? pos - llbbox.top : 0, outsideTickLen);\n                    domainIndices.reverse();\n                }\n\n                if(llbbox.width > 0) {\n                    var rExtra = llbbox.right - (ax._offset + ax._length);\n                    if(rExtra > 0) {\n                        push.xr = 1;\n                        push.r = rExtra;\n                    }\n                    var lExtra = ax._offset - llbbox.left;\n                    if(lExtra > 0) {\n                        push.xl = 0;\n                        push.l = lExtra;\n                    }\n                }\n            } else {\n                if(s === 'l') {\n                    ax._depth = Math.max(llbbox.height > 0 ? pos - llbbox.left : 0, outsideTickLen);\n                    push[s] = ax._depth - shift;\n                } else {\n                    ax._depth = Math.max(llbbox.height > 0 ? llbbox.right - pos : 0, outsideTickLen);\n                    push[s] = ax._depth + shift;\n                    domainIndices.reverse();\n                }\n\n                if(llbbox.height > 0) {\n                    var bExtra = llbbox.bottom - (ax._offset + ax._length);\n                    if(bExtra > 0) {\n                        push.yb = 0;\n                        push.b = bExtra;\n                    }\n                    var tExtra = ax._offset - llbbox.top;\n                    if(tExtra > 0) {\n                        push.yt = 1;\n                        push.t = tExtra;\n                    }\n                }\n            }\n\n            push[counterLetter] = ax.anchor === 'free' ?\n                ax.position :\n                ax._anchorAxis.domain[domainIndices[0]];\n\n            if(ax.title.text !== fullLayout._dfltTitle[axLetter]) {\n                push[s] += approxTitleDepth(ax) + (ax.title.standoff || 0);\n            }\n\n            if(ax.mirror && ax.anchor !== 'free') {\n                mirrorPush = {x: 0, y: 0, r: 0, l: 0, t: 0, b: 0};\n\n                mirrorPush[sMirror] = ax.linewidth;\n                if(ax.mirror && ax.mirror !== true) mirrorPush[sMirror] += outsideTickLen;\n\n                if(ax.mirror === true || ax.mirror === 'ticks') {\n                    mirrorPush[counterLetter] = ax._anchorAxis.domain[domainIndices[1]];\n                } else if(ax.mirror === 'all' || ax.mirror === 'allticks') {\n                    mirrorPush[counterLetter] = [ax._counterDomainMin, ax._counterDomainMax][domainIndices[1]];\n                }\n            }\n        }\n        if(hasRangeSlider) {\n            rangeSliderPush = Registry.getComponentMethod('rangeslider', 'autoMarginOpts')(gd, ax);\n        }\n\n        if(typeof ax.automargin === 'string') {\n            filterPush(push, ax.automargin);\n            filterPush(mirrorPush, ax.automargin);\n        }\n\n        Plots.autoMargin(gd, axAutoMarginID(ax), push);\n        Plots.autoMargin(gd, axMirrorAutoMarginID(ax), mirrorPush);\n        Plots.autoMargin(gd, rangeSliderAutoMarginID(ax), rangeSliderPush);\n    });\n\n    return Lib.syncOrAsync(seq);\n};\n\nfunction filterPush(push, automargin) {\n    if(!push) return;\n\n    var keepMargin = Object.keys(MARGIN_MAPPING).reduce(function(data, nextKey) {\n        if(automargin.indexOf(nextKey) !== -1) {\n            MARGIN_MAPPING[nextKey].forEach(function(key) { data[key] = 1;});\n        }\n        return data;\n    }, {});\n    Object.keys(push).forEach(function(key) {\n        if(!keepMargin[key]) {\n            if(key.length === 1) push[key] = 0;\n            else delete push[key];\n        }\n    });\n}\n\nfunction getBoundaryVals(ax, vals) {\n    var out = [];\n    var i;\n\n    // boundaryVals are never used for labels;\n    // no need to worry about the other tickTextObj keys\n    var _push = function(d, bndIndex) {\n        var xb = d.xbnd ? d.xbnd[bndIndex] : d.x;\n        if(xb !== null) {\n            out.push(Lib.extendFlat({}, d, {x: xb}));\n        }\n    };\n\n    if(vals.length) {\n        for(i = 0; i < vals.length; i++) {\n            _push(vals[i], 0);\n        }\n        _push(vals[i - 1], 1);\n    }\n\n    return out;\n}\n\nfunction getSecondaryLabelVals(ax, vals) {\n    var out = [];\n    var lookup = {};\n\n    for(var i = 0; i < vals.length; i++) {\n        var d = vals[i];\n        if(lookup[d.text2]) {\n            lookup[d.text2].push(d.x);\n        } else {\n            lookup[d.text2] = [d.x];\n        }\n    }\n\n    for(var k in lookup) {\n        out.push(tickTextObj(ax, Lib.interp(lookup[k], 0.5), k));\n    }\n\n    return out;\n}\n\nfunction getDividerVals(ax, vals) {\n    var out = [];\n    var i, current;\n\n    var reversed = (vals.length && vals[vals.length - 1].x < vals[0].x);\n\n    // never used for labels;\n    // no need to worry about the other tickTextObj keys\n    var _push = function(d, bndIndex) {\n        var xb = d.xbnd[bndIndex];\n        if(xb !== null) {\n            out.push(Lib.extendFlat({}, d, {x: xb}));\n        }\n    };\n\n    if(ax.showdividers && vals.length) {\n        for(i = 0; i < vals.length; i++) {\n            var d = vals[i];\n            if(d.text2 !== current) {\n                _push(d, reversed ? 1 : 0);\n            }\n            current = d.text2;\n        }\n        _push(vals[i - 1], reversed ? 0 : 1);\n    }\n\n    return out;\n}\n\nfunction calcLabelLevelBbox(ax, cls) {\n    var top, bottom;\n    var left, right;\n\n    if(ax._selections[cls].size()) {\n        top = Infinity;\n        bottom = -Infinity;\n        left = Infinity;\n        right = -Infinity;\n        ax._selections[cls].each(function() {\n            var thisLabel = selectTickLabel(this);\n            // Use parent node <g.(x|y)tick>, to make Drawing.bBox\n            // retrieve a bbox computed with transform info\n            //\n            // To improve perf, it would be nice to use `thisLabel.node()`\n            // (like in fixLabelOverlaps) instead and use Axes.getPxPosition\n            // together with the makeLabelFns outputs and `tickangle`\n            // to compute one bbox per (tick value x tick style)\n            var bb = Drawing.bBox(thisLabel.node().parentNode);\n            top = Math.min(top, bb.top);\n            bottom = Math.max(bottom, bb.bottom);\n            left = Math.min(left, bb.left);\n            right = Math.max(right, bb.right);\n        });\n    } else {\n        top = 0;\n        bottom = 0;\n        left = 0;\n        right = 0;\n    }\n\n    return {\n        top: top,\n        bottom: bottom,\n        left: left,\n        right: right,\n        height: bottom - top,\n        width: right - left\n    };\n}\n\n/**\n * Which direction do the 'ax.side' values, and free ticks go?\n *\n * @param {object} ax (full) axis object\n *  - {string} _id (starting with 'x' or 'y')\n *  - {string} side\n *  - {string} ticks\n * @return {array} all entries are either -1 or 1\n *  - [0]: sign for top/right ticks (i.e. negative SVG direction)\n *  - [1]: sign for bottom/left ticks (i.e. positive SVG direction)\n *  - [2]: sign for ticks corresponding to 'ax.side'\n *  - [3]: sign for ticks mirroring 'ax.side'\n *  - [4]: sign of arrow starting at axis pointing towards margin\n */\naxes.getTickSigns = function(ax, minor) {\n    var axLetter = ax._id.charAt(0);\n    var sideOpposite = {x: 'top', y: 'right'}[axLetter];\n    var main = ax.side === sideOpposite ? 1 : -1;\n    var out = [-1, 1, main, -main];\n    // then we flip if outside XOR y axis\n\n    var ticks = minor ? (ax.minor || {}).ticks : ax.ticks;\n    if((ticks !== 'inside') === (axLetter === 'x')) {\n        out = out.map(function(v) { return -v; });\n    }\n    // independent of `ticks`; do not flip this one\n    if(ax.side) {\n        out.push({l: -1, t: -1, r: 1, b: 1}[ax.side.charAt(0)]);\n    }\n    return out;\n};\n\n/**\n * Make axis translate transform function\n *\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {number} _offset\n *  - {fn} l2p\n * @return {fn} function of calcTicks items\n */\naxes.makeTransTickFn = function(ax) {\n    return ax._id.charAt(0) === 'x' ?\n        function(d) { return strTranslate(ax._offset + ax.l2p(d.x), 0); } :\n        function(d) { return strTranslate(0, ax._offset + ax.l2p(d.x)); };\n};\n\naxes.makeTransTickLabelFn = function(ax) {\n    var uv = getTickLabelUV(ax);\n    var u = uv[0];\n    var v = uv[1];\n\n    return ax._id.charAt(0) === 'x' ?\n        function(d) {\n            return strTranslate(\n                u + ax._offset + ax.l2p(getPosX(d)),\n                v\n            );\n        } :\n        function(d) {\n            return strTranslate(\n                v,\n                u + ax._offset + ax.l2p(getPosX(d))\n            );\n        };\n};\n\nfunction getPosX(d) {\n    return d.periodX !== undefined ? d.periodX : d.x;\n}\n\n// u is a shift along the axis,\n// v is a shift perpendicular to the axis\nfunction getTickLabelUV(ax) {\n    var ticklabelposition = ax.ticklabelposition || '';\n    var has = function(str) {\n        return ticklabelposition.indexOf(str) !== -1;\n    };\n\n    var isTop = has('top');\n    var isLeft = has('left');\n    var isRight = has('right');\n    var isBottom = has('bottom');\n    var isInside = has('inside');\n\n    var isAligned = isBottom || isLeft || isTop || isRight;\n\n    // early return\n    if(!isAligned && !isInside) return [0, 0];\n\n    var side = ax.side;\n\n    var u = isAligned ? (ax.tickwidth || 0) / 2 : 0;\n    var v = TEXTPAD;\n\n    var fontSize = ax.tickfont ? ax.tickfont.size : 12;\n    if(isBottom || isTop) {\n        u += fontSize * CAP_SHIFT;\n        v += (ax.linewidth || 0) / 2;\n    }\n    if(isLeft || isRight) {\n        u += (ax.linewidth || 0) / 2;\n        v += TEXTPAD;\n    }\n    if(isInside && side === 'top') {\n        v -= fontSize * (1 - CAP_SHIFT);\n    }\n\n    if(isLeft || isTop) u = -u;\n    if(side === 'bottom' || side === 'right') v = -v;\n\n    return [\n        isAligned ? u : 0,\n        isInside ? v : 0\n    ];\n}\n\n/**\n * Make axis tick path string\n *\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {number} ticklen\n *  - {number} linewidth\n * @param {number} shift along direction of ticklen\n * @param {1 or -1} sgn tick sign\n * @param {object} opts\n * - {number (optional)} len tick length\n * @return {string}\n */\naxes.makeTickPath = function(ax, shift, sgn, opts) {\n    if(!opts) opts = {};\n    var minor = opts.minor;\n    if(minor && !ax.minor) return '';\n\n    var len = opts.len !== undefined ? opts.len :\n        minor ? ax.minor.ticklen : ax.ticklen;\n\n    var axLetter = ax._id.charAt(0);\n    var pad = (ax.linewidth || 1) / 2;\n\n    return axLetter === 'x' ?\n        'M0,' + (shift + pad * sgn) + 'v' + (len * sgn) :\n        'M' + (shift + pad * sgn) + ',0h' + (len * sgn);\n};\n\n/**\n * Make axis tick label x, y and anchor functions\n *\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {string} ticks\n *  - {number} ticklen\n *  - {string} side\n *  - {number} linewidth\n *  - {number} tickfont.size\n *  - {boolean} showline\n * @param {number} shift\n * @param {number} angle [in degrees] ...\n * @return {object}\n *  - {fn} xFn\n *  - {fn} yFn\n *  - {fn} anchorFn\n *  - {fn} heightFn\n *  - {number} labelStandoff (gap parallel to ticks)\n *  - {number} labelShift (gap perpendicular to ticks)\n */\naxes.makeLabelFns = function(ax, shift, angle) {\n    var ticklabelposition = ax.ticklabelposition || '';\n    var has = function(str) {\n        return ticklabelposition.indexOf(str) !== -1;\n    };\n\n    var isTop = has('top');\n    var isLeft = has('left');\n    var isRight = has('right');\n    var isBottom = has('bottom');\n    var isAligned = isBottom || isLeft || isTop || isRight;\n\n    var insideTickLabels = has('inside');\n    var labelsOverTicks =\n        (ticklabelposition === 'inside' && ax.ticks === 'inside') ||\n        (!insideTickLabels && ax.ticks === 'outside' && ax.tickson !== 'boundaries');\n\n    var labelStandoff = 0;\n    var labelShift = 0;\n\n    var tickLen = labelsOverTicks ? ax.ticklen : 0;\n    if(insideTickLabels) {\n        tickLen *= -1;\n    } else if(isAligned) {\n        tickLen = 0;\n    }\n\n    if(labelsOverTicks) {\n        labelStandoff += tickLen;\n        if(angle) {\n            var rad = Lib.deg2rad(angle);\n            labelStandoff = tickLen * Math.cos(rad) + 1;\n            labelShift = tickLen * Math.sin(rad);\n        }\n    }\n\n    if(ax.showticklabels && (labelsOverTicks || ax.showline)) {\n        labelStandoff += 0.2 * ax.tickfont.size;\n    }\n    labelStandoff += (ax.linewidth || 1) / 2 * (insideTickLabels ? -1 : 1);\n\n    var out = {\n        labelStandoff: labelStandoff,\n        labelShift: labelShift\n    };\n\n    var x0, y0, ff, flipIt;\n    var xQ = 0;\n\n    var side = ax.side;\n    var axLetter = ax._id.charAt(0);\n    var tickangle = ax.tickangle;\n    var endSide;\n    if(axLetter === 'x') {\n        endSide =\n            (!insideTickLabels && side === 'bottom') ||\n            (insideTickLabels && side === 'top');\n\n        flipIt = endSide ? 1 : -1;\n        if(insideTickLabels) flipIt *= -1;\n\n        x0 = labelShift * flipIt;\n        y0 = shift + labelStandoff * flipIt;\n        ff = endSide ? 1 : -0.2;\n        if(Math.abs(tickangle) === 90) {\n            if(insideTickLabels) {\n                ff += MID_SHIFT;\n            } else {\n                if(tickangle === -90 && side === 'bottom') {\n                    ff = CAP_SHIFT;\n                } else if(tickangle === 90 && side === 'top') {\n                    ff = MID_SHIFT;\n                } else {\n                    ff = 0.5;\n                }\n            }\n\n            xQ = (MID_SHIFT / 2) * (tickangle / 90);\n        }\n\n        out.xFn = function(d) { return d.dx + x0 + xQ * d.fontSize; };\n        out.yFn = function(d) { return d.dy + y0 + d.fontSize * ff; };\n        out.anchorFn = function(d, a) {\n            if(isAligned) {\n                if(isLeft) return 'end';\n                if(isRight) return 'start';\n            }\n\n            if(!isNumeric(a) || a === 0 || a === 180) {\n                return 'middle';\n            }\n\n            return ((a * flipIt < 0) !== insideTickLabels) ? 'end' : 'start';\n        };\n        out.heightFn = function(d, a, h) {\n            return (a < -60 || a > 60) ? -0.5 * h :\n                ((ax.side === 'top') !== insideTickLabels) ? -h :\n                0;\n        };\n    } else if(axLetter === 'y') {\n        endSide =\n            (!insideTickLabels && side === 'left') ||\n            (insideTickLabels && side === 'right');\n\n        flipIt = endSide ? 1 : -1;\n        if(insideTickLabels) flipIt *= -1;\n\n        x0 = labelStandoff;\n        y0 = labelShift * flipIt;\n        ff = 0;\n        if(!insideTickLabels && Math.abs(tickangle) === 90) {\n            if(\n                (tickangle === -90 && side === 'left') ||\n                (tickangle === 90 && side === 'right')\n            ) {\n                ff = CAP_SHIFT;\n            } else {\n                ff = 0.5;\n            }\n        }\n\n        if(insideTickLabels) {\n            var ang = isNumeric(tickangle) ? +tickangle : 0;\n            if(ang !== 0) {\n                var rA = Lib.deg2rad(ang);\n                xQ = Math.abs(Math.sin(rA)) * CAP_SHIFT * flipIt;\n                ff = 0;\n            }\n        }\n\n        out.xFn = function(d) { return d.dx + shift - (x0 + d.fontSize * ff) * flipIt + xQ * d.fontSize; };\n        out.yFn = function(d) { return d.dy + y0 + d.fontSize * MID_SHIFT; };\n        out.anchorFn = function(d, a) {\n            if(isNumeric(a) && Math.abs(a) === 90) {\n                return 'middle';\n            }\n\n            return endSide ? 'end' : 'start';\n        };\n        out.heightFn = function(d, a, h) {\n            if(ax.side === 'right') a *= -1;\n\n            return a < -30 ? -h :\n                a < 30 ? -0.5 * h :\n                0;\n        };\n    }\n\n    return out;\n};\n\nfunction tickDataFn(d) {\n    return [d.text, d.x, d.axInfo, d.font, d.fontSize, d.fontColor].join('_');\n}\n\n/**\n * Draw axis ticks\n *\n * @param {DOM element} gd\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {string} ticks\n *  - {number} linewidth\n *  - {string} tickcolor\n * @param {object} opts\n * - {array of object} vals (calcTicks output-like)\n * - {d3 selection} layer\n * - {string or fn} path\n * - {fn} transFn\n * - {boolean} crisp (set to false to unset crisp-edge SVG rendering)\n */\naxes.drawTicks = function(gd, ax, opts) {\n    opts = opts || {};\n\n    var cls = ax._id + 'tick';\n\n    var vals = []\n        .concat(ax.minor && ax.minor.ticks ?\n            // minor vals\n            opts.vals.filter(function(d) { return d.minor && !d.noTick; }) :\n            []\n        )\n        .concat(ax.ticks ?\n            // major vals\n            opts.vals.filter(function(d) { return !d.minor && !d.noTick; }) :\n            []\n        );\n\n    var ticks = opts.layer.selectAll('path.' + cls)\n        .data(vals, tickDataFn);\n\n    ticks.exit().remove();\n\n    ticks.enter().append('path')\n        .classed(cls, 1)\n        .classed('ticks', 1)\n        .classed('crisp', opts.crisp !== false)\n        .each(function(d) {\n            return Color.stroke(d3.select(this), d.minor ? ax.minor.tickcolor : ax.tickcolor);\n        })\n        .style('stroke-width', function(d) {\n            return Drawing.crispRound(\n                gd,\n                d.minor ? ax.minor.tickwidth : ax.tickwidth,\n                1\n            ) + 'px';\n        })\n        .attr('d', opts.path)\n        .style('display', null); // visible\n\n    hideCounterAxisInsideTickLabels(ax, [TICK_PATH]);\n\n    ticks.attr('transform', opts.transFn);\n};\n\n/**\n * Draw axis grid\n *\n * @param {DOM element} gd\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {boolean} showgrid\n *  - {string} gridcolor\n *  - {string} gridwidth\n *  - {string} griddash\n *  - {boolean} zeroline\n *  - {string} type\n *  - {string} dtick\n * @param {object} opts\n * - {array of object} vals (calcTicks output-like)\n * - {d3 selection} layer\n * - {object} counterAxis (full axis object corresponding to counter axis)\n *     optional - only required if this axis supports zero lines\n * - {string or fn} path\n * - {fn} transFn\n * - {boolean} crisp (set to false to unset crisp-edge SVG rendering)\n */\naxes.drawGrid = function(gd, ax, opts) {\n    opts = opts || {};\n\n    if(ax.tickmode === 'sync') {\n        // for tickmode sync we use the overlaying axis grid\n        return;\n    }\n\n    var cls = ax._id + 'grid';\n\n    var hasMinor = ax.minor && ax.minor.showgrid;\n    var minorVals = hasMinor ? opts.vals.filter(function(d) { return d.minor; }) : [];\n    var majorVals = ax.showgrid ? opts.vals.filter(function(d) { return !d.minor; }) : [];\n\n    var counterAx = opts.counterAxis;\n    if(counterAx && axes.shouldShowZeroLine(gd, ax, counterAx)) {\n        var isArrayMode = ax.tickmode === 'array';\n        for(var i = 0; i < majorVals.length; i++) {\n            var xi = majorVals[i].x;\n            if(isArrayMode ? !xi : (Math.abs(xi) < ax.dtick / 100)) {\n                majorVals = majorVals.slice(0, i).concat(majorVals.slice(i + 1));\n                // In array mode you can in principle have multiple\n                // ticks at 0, so test them all. Otherwise once we found\n                // one we can stop.\n                if(isArrayMode) i--;\n                else break;\n            }\n        }\n    }\n\n    ax._gw =\n        Drawing.crispRound(gd, ax.gridwidth, 1);\n\n    var wMinor = !hasMinor ? 0 :\n        Drawing.crispRound(gd, ax.minor.gridwidth, 1);\n\n    var majorLayer = opts.layer;\n    var minorLayer = opts.minorLayer;\n    for(var major = 1; major >= 0; major--) {\n        var layer = major ? majorLayer : minorLayer;\n        if(!layer) continue;\n\n        var grid = layer.selectAll('path.' + cls)\n            .data(major ? majorVals : minorVals, tickDataFn);\n\n        grid.exit().remove();\n\n        grid.enter().append('path')\n            .classed(cls, 1)\n            .classed('crisp', opts.crisp !== false);\n\n        grid.attr('transform', opts.transFn)\n            .attr('d', opts.path)\n            .each(function(d) {\n                return Color.stroke(d3.select(this), d.minor ?\n                    ax.minor.gridcolor :\n                    (ax.gridcolor || '#ddd')\n                );\n            })\n            .style('stroke-dasharray', function(d) {\n                return Drawing.dashStyle(\n                    d.minor ? ax.minor.griddash : ax.griddash,\n                    d.minor ? ax.minor.gridwidth : ax.gridwidth\n                );\n            })\n            .style('stroke-width', function(d) {\n                return (d.minor ? wMinor : ax._gw) + 'px';\n            })\n            .style('display', null); // visible\n\n        if(typeof opts.path === 'function') grid.attr('d', opts.path);\n    }\n\n    hideCounterAxisInsideTickLabels(ax, [GRID_PATH, MINORGRID_PATH]);\n};\n\n/**\n * Draw axis zero-line\n *\n * @param {DOM element} gd\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {boolean} zeroline\n *  - {number} zerolinewidth\n *  - {string} zerolinecolor\n *  - {number (optional)} _gridWidthCrispRound\n * @param {object} opts\n * - {d3 selection} layer\n * - {object} counterAxis (full axis object corresponding to counter axis)\n * - {string or fn} path\n * - {fn} transFn\n * - {boolean} crisp (set to false to unset crisp-edge SVG rendering)\n */\naxes.drawZeroLine = function(gd, ax, opts) {\n    opts = opts || opts;\n\n    var cls = ax._id + 'zl';\n    var show = axes.shouldShowZeroLine(gd, ax, opts.counterAxis);\n\n    var zl = opts.layer.selectAll('path.' + cls)\n        .data(show ? [{x: 0, id: ax._id}] : []);\n\n    zl.exit().remove();\n\n    zl.enter().append('path')\n        .classed(cls, 1)\n        .classed('zl', 1)\n        .classed('crisp', opts.crisp !== false)\n        .each(function() {\n            // use the fact that only one element can enter to trigger a sort.\n            // If several zerolines enter at the same time we will sort once per,\n            // but generally this should be a minimal overhead.\n            opts.layer.selectAll('path').sort(function(da, db) {\n                return idSort(da.id, db.id);\n            });\n        });\n\n    zl.attr('transform', opts.transFn)\n        .attr('d', opts.path)\n        .call(Color.stroke, ax.zerolinecolor || Color.defaultLine)\n        .style('stroke-width', Drawing.crispRound(gd, ax.zerolinewidth, ax._gw || 1) + 'px')\n        .style('display', null); // visible\n\n    hideCounterAxisInsideTickLabels(ax, [ZERO_PATH]);\n};\n\n/**\n * Draw axis tick labels\n *\n * @param {DOM element} gd\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {boolean} showticklabels\n *  - {number} tickangle\n *  - {object (optional)} _selections\n *  - {object} (optional)} _tickAngles\n *  - {object} (optional)} _prevTickAngles\n * @param {object} opts\n * - {array of object} vals (calcTicks output-like)\n * - {d3 selection} layer\n * - {string (optional)} cls (node className)\n * - {boolean} repositionOnUpdate (set to true to reposition update selection)\n * - {boolean} secondary\n * - {fn} transFn\n * - {object} labelFns\n *  + {fn} xFn\n *  + {fn} yFn\n *  + {fn} anchorFn\n *  + {fn} heightFn\n */\naxes.drawLabels = function(gd, ax, opts) {\n    opts = opts || {};\n\n    var fullLayout = gd._fullLayout;\n    var axId = ax._id;\n    var cls = opts.cls || axId + 'tick';\n\n    var vals = opts.vals.filter(function(d) { return d.text; });\n\n    var labelFns = opts.labelFns;\n    var tickAngle = opts.secondary ? 0 : ax.tickangle;\n\n    var prevAngle = (ax._prevTickAngles || {})[cls];\n\n    var tickLabels = opts.layer.selectAll('g.' + cls)\n        .data(ax.showticklabels ? vals : [], tickDataFn);\n\n    var labelsReady = [];\n\n    tickLabels.enter().append('g')\n        .classed(cls, 1)\n        .append('text')\n            // only so tex has predictable alignment that we can\n            // alter later\n            .attr('text-anchor', 'middle')\n            .each(function(d) {\n                var thisLabel = d3.select(this);\n                var newPromise = gd._promises.length;\n\n                thisLabel\n                    .call(svgTextUtils.positionText, labelFns.xFn(d), labelFns.yFn(d))\n                    .call(Drawing.font, d.font, d.fontSize, d.fontColor)\n                    .text(d.text)\n                    .call(svgTextUtils.convertToTspans, gd);\n\n                if(gd._promises[newPromise]) {\n                    // if we have an async label, we'll deal with that\n                    // all here so take it out of gd._promises and\n                    // instead position the label and promise this in\n                    // labelsReady\n                    labelsReady.push(gd._promises.pop().then(function() {\n                        positionLabels(thisLabel, tickAngle);\n                    }));\n                } else {\n                    // sync label: just position it now.\n                    positionLabels(thisLabel, tickAngle);\n                }\n            });\n\n    hideCounterAxisInsideTickLabels(ax, [TICK_TEXT]);\n\n    tickLabels.exit().remove();\n\n    if(opts.repositionOnUpdate) {\n        tickLabels.each(function(d) {\n            d3.select(this).select('text')\n                .call(svgTextUtils.positionText, labelFns.xFn(d), labelFns.yFn(d));\n        });\n    }\n\n    function positionLabels(s, angle) {\n        s.each(function(d) {\n            var thisLabel = d3.select(this);\n            var mathjaxGroup = thisLabel.select('.text-math-group');\n            var anchor = labelFns.anchorFn(d, angle);\n\n            var transform = opts.transFn.call(thisLabel.node(), d) +\n                ((isNumeric(angle) && +angle !== 0) ?\n                (' rotate(' + angle + ',' + labelFns.xFn(d) + ',' +\n                    (labelFns.yFn(d) - d.fontSize / 2) + ')') :\n                '');\n\n            // how much to shift a multi-line label to center it vertically.\n            var nLines = svgTextUtils.lineCount(thisLabel);\n            var lineHeight = LINE_SPACING * d.fontSize;\n            var anchorHeight = labelFns.heightFn(d, isNumeric(angle) ? +angle : 0, (nLines - 1) * lineHeight);\n\n            if(anchorHeight) {\n                transform += strTranslate(0, anchorHeight);\n            }\n\n            if(mathjaxGroup.empty()) {\n                var thisText = thisLabel.select('text');\n                thisText.attr({\n                    transform: transform,\n                    'text-anchor': anchor\n                });\n\n                thisText.style('opacity', 1); // visible\n\n                if(ax._adjustTickLabelsOverflow) {\n                    ax._adjustTickLabelsOverflow();\n                }\n            } else {\n                var mjWidth = Drawing.bBox(mathjaxGroup.node()).width;\n                var mjShift = mjWidth * {end: -0.5, start: 0.5}[anchor];\n                mathjaxGroup.attr('transform', transform + strTranslate(mjShift, 0));\n            }\n        });\n    }\n\n    ax._adjustTickLabelsOverflow = function() {\n        var ticklabeloverflow = ax.ticklabeloverflow;\n        if(!ticklabeloverflow || ticklabeloverflow === 'allow') return;\n\n        var hideOverflow = ticklabeloverflow.indexOf('hide') !== -1;\n\n        var isX = ax._id.charAt(0) === 'x';\n        // div positions\n        var p0 = 0;\n        var p1 = isX ?\n            gd._fullLayout.width :\n            gd._fullLayout.height;\n\n        if(ticklabeloverflow.indexOf('domain') !== -1) {\n            // domain positions\n            var rl = Lib.simpleMap(ax.range, ax.r2l);\n            p0 = ax.l2p(rl[0]) + ax._offset;\n            p1 = ax.l2p(rl[1]) + ax._offset;\n        }\n\n        var min = Math.min(p0, p1);\n        var max = Math.max(p0, p1);\n\n        var side = ax.side;\n\n        var visibleLabelMin = Infinity;\n        var visibleLabelMax = -Infinity;\n\n        tickLabels.each(function(d) {\n            var thisLabel = d3.select(this);\n            var mathjaxGroup = thisLabel.select('.text-math-group');\n\n            if(mathjaxGroup.empty()) {\n                var bb = Drawing.bBox(thisLabel.node());\n                var adjust = 0;\n                if(isX) {\n                    if(bb.right > max) adjust = 1;\n                    else if(bb.left < min) adjust = 1;\n                } else {\n                    if(bb.bottom > max) adjust = 1;\n                    else if(bb.top + (ax.tickangle ? 0 : d.fontSize / 4) < min) adjust = 1;\n                }\n\n                var t = thisLabel.select('text');\n                if(adjust) {\n                    if(hideOverflow) t.style('opacity', 0); // hidden\n                } else {\n                    t.style('opacity', 1); // visible\n\n                    if(side === 'bottom' || side === 'right') {\n                        visibleLabelMin = Math.min(visibleLabelMin, isX ? bb.top : bb.left);\n                    } else {\n                        visibleLabelMin = -Infinity;\n                    }\n\n                    if(side === 'top' || side === 'left') {\n                        visibleLabelMax = Math.max(visibleLabelMax, isX ? bb.bottom : bb.right);\n                    } else {\n                        visibleLabelMax = Infinity;\n                    }\n                }\n            } // TODO: hide mathjax?\n        });\n\n        for(var subplot in fullLayout._plots) {\n            var plotinfo = fullLayout._plots[subplot];\n            if(ax._id !== plotinfo.xaxis._id && ax._id !== plotinfo.yaxis._id) continue;\n            var anchorAx = isX ? plotinfo.yaxis : plotinfo.xaxis;\n            if(anchorAx) {\n                anchorAx['_visibleLabelMin_' + ax._id] = visibleLabelMin;\n                anchorAx['_visibleLabelMax_' + ax._id] = visibleLabelMax;\n            }\n        }\n    };\n\n    ax._hideCounterAxisInsideTickLabels = function(partialOpts) {\n        var isX = ax._id.charAt(0) === 'x';\n\n        var anchoredAxes = [];\n        for(var subplot in fullLayout._plots) {\n            var plotinfo = fullLayout._plots[subplot];\n            if(ax._id !== plotinfo.xaxis._id && ax._id !== plotinfo.yaxis._id) continue;\n            anchoredAxes.push(isX ? plotinfo.yaxis : plotinfo.xaxis);\n        }\n\n        anchoredAxes.forEach(function(anchorAx, idx) {\n            if(anchorAx && insideTicklabelposition(anchorAx)) {\n                (partialOpts || [\n                    ZERO_PATH,\n                    MINORGRID_PATH,\n                    GRID_PATH,\n                    TICK_PATH,\n                    TICK_TEXT\n                ]).forEach(function(e) {\n                    var isPeriodLabel =\n                        e.K === 'tick' &&\n                        e.L === 'text' &&\n                        ax.ticklabelmode === 'period';\n\n                    var mainPlotinfo = fullLayout._plots[ax._mainSubplot];\n\n                    var sel;\n                    if(e.K === ZERO_PATH.K) sel = mainPlotinfo.zerolinelayer.selectAll('.' + ax._id + 'zl');\n                    else if(e.K === MINORGRID_PATH.K) sel = mainPlotinfo.minorGridlayer.selectAll('.' + ax._id);\n                    else if(e.K === GRID_PATH.K) sel = mainPlotinfo.gridlayer.selectAll('.' + ax._id);\n                    else sel = mainPlotinfo[ax._id.charAt(0) + 'axislayer'];\n\n                    sel.each(function() {\n                        var w = d3.select(this);\n                        if(e.L) w = w.selectAll(e.L);\n\n                        w.each(function(d) {\n                            var q = ax.l2p(\n                                isPeriodLabel ? getPosX(d) : d.x\n                            ) + ax._offset;\n\n                            var t = d3.select(this);\n                            if(\n                                q < ax['_visibleLabelMax_' + anchorAx._id] &&\n                                q > ax['_visibleLabelMin_' + anchorAx._id]\n                            ) {\n                                t.style('display', 'none'); // hidden\n                            } else if(e.K === 'tick' && !idx) {\n                                t.style('display', null); // visible\n                            }\n                        });\n                    });\n                });\n            }\n        });\n    };\n\n    // make sure all labels are correctly positioned at their base angle\n    // the positionLabels call above is only for newly drawn labels.\n    // do this without waiting, using the last calculated angle to\n    // minimize flicker, then do it again when we know all labels are\n    // there, putting back the prescribed angle to check for overlaps.\n    positionLabels(tickLabels, (prevAngle + 1) ? prevAngle : tickAngle);\n\n    function allLabelsReady() {\n        return labelsReady.length && Promise.all(labelsReady);\n    }\n\n    var autoangle = null;\n\n    function fixLabelOverlaps() {\n        positionLabels(tickLabels, tickAngle);\n\n        // check for auto-angling if x labels overlap\n        // don't auto-angle at all for log axes with\n        // base and digit format\n        if(vals.length && ax.autotickangles &&\n            (ax.type !== 'log' || String(ax.dtick).charAt(0) !== 'D')\n        ) {\n            autoangle = ax.autotickangles[0];\n\n            var maxFontSize = 0;\n            var lbbArray = [];\n            var i;\n            var maxLines = 1;\n            tickLabels.each(function(d) {\n                maxFontSize = Math.max(maxFontSize, d.fontSize);\n\n                var x = ax.l2p(d.x);\n                var thisLabel = selectTickLabel(this);\n                var bb = Drawing.bBox(thisLabel.node());\n                maxLines = Math.max(maxLines, svgTextUtils.lineCount(thisLabel));\n\n                lbbArray.push({\n                    // ignore about y, just deal with x overlaps\n                    top: 0,\n                    bottom: 10,\n                    height: 10,\n                    left: x - bb.width / 2,\n                    // impose a 2px gap\n                    right: x + bb.width / 2 + 2,\n                    width: bb.width + 2\n                });\n            });\n\n            if((ax.tickson === 'boundaries' || ax.showdividers) && !opts.secondary) {\n                var gap = 2;\n                if(ax.ticks) gap += ax.tickwidth / 2;\n\n                // TODO should secondary labels also fall into this fix-overlap regime?\n\n                for(i = 0; i < lbbArray.length; i++) {\n                    var xbnd = (vals && vals[i].xbnd) ? vals[i].xbnd : [null, null];\n                    var lbb = lbbArray[i];\n                    if(\n                        (xbnd[0] !== null && (lbb.left - ax.l2p(xbnd[0])) < gap) ||\n                        (xbnd[1] !== null && (ax.l2p(xbnd[1]) - lbb.right) < gap)\n                    ) {\n                        autoangle = 90;\n                        break;\n                    }\n                }\n            } else {\n                var vLen = vals.length;\n                var tickSpacing = Math.abs((vals[vLen - 1].x - vals[0].x) * ax._m) / (vLen - 1);\n\n                var ticklabelposition = ax.ticklabelposition || '';\n                var has = function(str) {\n                    return ticklabelposition.indexOf(str) !== -1;\n                };\n                var isTop = has('top');\n                var isLeft = has('left');\n                var isRight = has('right');\n                var isBottom = has('bottom');\n                var isAligned = isBottom || isLeft || isTop || isRight;\n                var pad = !isAligned ? 0 :\n                    (ax.tickwidth || 0) + 2 * TEXTPAD;\n\n                // autotickangles\n                var adjacent = tickSpacing;\n                var opposite = maxFontSize * 1.25 * maxLines;\n                var hypotenuse = Math.sqrt(Math.pow(adjacent, 2) + Math.pow(opposite, 2));\n                var maxCos = adjacent / hypotenuse;\n                var autoTickAnglesRadians = ax.autotickangles.map(\n                    function(degrees) { return degrees * Math.PI / 180; }\n                );\n                var angleRadians = autoTickAnglesRadians.find(\n                    function(angle) { return Math.abs(Math.cos(angle)) <= maxCos; }\n                );\n                if(angleRadians === undefined) {\n                    // no angle with smaller cosine than maxCos, just pick the angle with smallest cosine\n                    angleRadians = autoTickAnglesRadians.reduce(\n                        function(currentMax, nextAngle) {\n                            return Math.abs(Math.cos(currentMax)) < Math.abs(Math.cos(nextAngle)) ? currentMax : nextAngle;\n                        }\n                        , autoTickAnglesRadians[0]\n                    );\n                }\n                var newAngle = angleRadians * (180 / Math.PI /* to degrees */);\n\n                for(i = 0; i < lbbArray.length - 1; i++) {\n                    if(Lib.bBoxIntersect(lbbArray[i], lbbArray[i + 1], pad)) {\n                        autoangle = newAngle;\n                        break;\n                    }\n                }\n            }\n\n            if(autoangle) {\n                positionLabels(tickLabels, autoangle);\n            }\n        }\n    }\n\n    if(ax._selections) {\n        ax._selections[cls] = tickLabels;\n    }\n\n    var seq = [allLabelsReady];\n\n    // N.B. during auto-margin redraws, if the axis fixed its label overlaps\n    // by rotating 90 degrees, do not attempt to re-fix its label overlaps\n    // as this can lead to infinite redraw loops!\n    if(ax.automargin && fullLayout._redrawFromAutoMarginCount && prevAngle === 90) {\n        autoangle = prevAngle;\n        seq.push(function() {\n            positionLabels(tickLabels, prevAngle);\n        });\n    } else {\n        seq.push(fixLabelOverlaps);\n    }\n\n    // save current tick angle for future redraws\n    if(ax._tickAngles) {\n        seq.push(function() {\n            ax._tickAngles[cls] = autoangle === null ?\n                (isNumeric(tickAngle) ? tickAngle : 0) :\n                autoangle;\n        });\n    }\n\n    var computeTickLabelBoundingBoxes = function() {\n        var labelsMaxW = 0;\n        var labelsMaxH = 0;\n        tickLabels.each(function(d, i) {\n            var thisLabel = selectTickLabel(this);\n            var mathjaxGroup = thisLabel.select('.text-math-group');\n\n            if(mathjaxGroup.empty()) {\n                var bb;\n\n                if(ax._vals[i]) {\n                    bb = ax._vals[i].bb || Drawing.bBox(thisLabel.node());\n                    ax._vals[i].bb = bb;\n                }\n\n                labelsMaxW = Math.max(labelsMaxW, bb.width);\n                labelsMaxH = Math.max(labelsMaxH, bb.height);\n            }\n        });\n\n        return {\n            labelsMaxW: labelsMaxW,\n            labelsMaxH: labelsMaxH\n        };\n    };\n\n    var anchorAx = ax._anchorAxis;\n    if(\n        anchorAx && (anchorAx.autorange || anchorAx.insiderange) &&\n        insideTicklabelposition(ax) &&\n        !isLinked(fullLayout, ax._id)\n    ) {\n        if(!fullLayout._insideTickLabelsUpdaterange) {\n            fullLayout._insideTickLabelsUpdaterange = {};\n        }\n\n        if(anchorAx.autorange) {\n            fullLayout._insideTickLabelsUpdaterange[anchorAx._name + '.autorange'] = anchorAx.autorange;\n\n            seq.push(computeTickLabelBoundingBoxes);\n        }\n\n        if(anchorAx.insiderange) {\n            var BBs = computeTickLabelBoundingBoxes();\n            var move = ax._id.charAt(0) === 'y' ?\n                BBs.labelsMaxW :\n                BBs.labelsMaxH;\n\n            move += 2 * TEXTPAD;\n\n            if(ax.ticklabelposition === 'inside') {\n                move += ax.ticklen || 0;\n            }\n\n            var sgn = (ax.side === 'right' || ax.side === 'top') ? 1 : -1;\n            var index = sgn === 1 ? 1 : 0;\n            var otherIndex = sgn === 1 ? 0 : 1;\n\n            var newRange = [];\n            newRange[otherIndex] = anchorAx.range[otherIndex];\n\n            var anchorAxRange = anchorAx.range;\n\n            var p0 = anchorAx.d2p(anchorAxRange[index]);\n            var p1 = anchorAx.d2p(anchorAxRange[otherIndex]);\n\n            var _tempNewRange = fullLayout._insideTickLabelsUpdaterange[anchorAx._name + '.range'];\n            if(_tempNewRange) { // case of having multiple anchored axes having insideticklabel\n                var q0 = anchorAx.d2p(_tempNewRange[index]);\n                var q1 = anchorAx.d2p(_tempNewRange[otherIndex]);\n\n                var dir = sgn * (ax._id.charAt(0) === 'y' ? 1 : -1);\n\n                if(dir * p0 < dir * q0) {\n                    p0 = q0;\n                    newRange[index] = anchorAxRange[index] = _tempNewRange[index];\n                }\n\n                if(dir * p1 > dir * q1) {\n                    p1 = q1;\n                    newRange[otherIndex] = anchorAxRange[otherIndex] = _tempNewRange[otherIndex];\n                }\n            }\n\n            var dist = Math.abs(p1 - p0);\n            if(dist - move > 0) {\n                dist -= move;\n                move *= 1 + move / dist;\n            } else {\n                move = 0;\n            }\n\n            if(ax._id.charAt(0) !== 'y') move = -move;\n\n            newRange[index] = anchorAx.p2d(\n                anchorAx.d2p(anchorAxRange[index]) +\n                sgn * move\n            );\n\n            // handle partial ranges in insiderange\n            if(\n                anchorAx.autorange === 'min' ||\n                anchorAx.autorange === 'max reversed'\n            ) {\n                newRange[0] = null;\n\n                anchorAx._rangeInitial0 = undefined;\n                anchorAx._rangeInitial1 = undefined;\n            } else if(\n                anchorAx.autorange === 'max' ||\n                anchorAx.autorange === 'min reversed'\n            ) {\n                newRange[1] = null;\n\n                anchorAx._rangeInitial0 = undefined;\n                anchorAx._rangeInitial1 = undefined;\n            }\n\n            fullLayout._insideTickLabelsUpdaterange[anchorAx._name + '.range'] = newRange;\n        }\n    }\n\n    var done = Lib.syncOrAsync(seq);\n    if(done && done.then) gd._promises.push(done);\n    return done;\n};\n\n/**\n * Draw axis dividers\n *\n * @param {DOM element} gd\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {string} showdividers\n *  - {number} dividerwidth\n *  - {string} dividercolor\n * @param {object} opts\n * - {array of object} vals (calcTicks output-like)\n * - {d3 selection} layer\n * - {fn} path\n * - {fn} transFn\n */\nfunction drawDividers(gd, ax, opts) {\n    var cls = ax._id + 'divider';\n    var vals = opts.vals;\n\n    var dividers = opts.layer.selectAll('path.' + cls)\n        .data(vals, tickDataFn);\n\n    dividers.exit().remove();\n\n    dividers.enter().insert('path', ':first-child')\n        .classed(cls, 1)\n        .classed('crisp', 1)\n        .call(Color.stroke, ax.dividercolor)\n        .style('stroke-width', Drawing.crispRound(gd, ax.dividerwidth, 1) + 'px');\n\n    dividers\n        .attr('transform', opts.transFn)\n        .attr('d', opts.path);\n}\n\n/**\n * Get axis position in px, that is the distance for the graph's\n * top (left) edge for x (y) axes.\n *\n * @param {DOM element} gd\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {string} side\n *  if anchored:\n *  - {object} _anchorAxis\n *  Otherwise:\n *  - {number} position\n * @return {number}\n */\naxes.getPxPosition = function(gd, ax) {\n    var gs = gd._fullLayout._size;\n    var axLetter = ax._id.charAt(0);\n    var side = ax.side;\n    var anchorAxis;\n\n    if(ax.anchor !== 'free') {\n        anchorAxis = ax._anchorAxis;\n    } else if(axLetter === 'x') {\n        anchorAxis = {\n            _offset: gs.t + (1 - (ax.position || 0)) * gs.h,\n            _length: 0\n        };\n    } else if(axLetter === 'y') {\n        anchorAxis = {\n            _offset: gs.l + (ax.position || 0) * gs.w + ax._shift,\n            _length: 0\n        };\n    }\n\n    if(side === 'top' || side === 'left') {\n        return anchorAxis._offset;\n    } else if(side === 'bottom' || side === 'right') {\n        return anchorAxis._offset + anchorAxis._length;\n    }\n};\n\n/**\n * Approximate axis title depth (w/o computing its bounding box)\n *\n * @param {object} ax (full) axis object\n *  - {string} title.text\n *  - {number} title.font.size\n *  - {number} title.standoff\n * @return {number} (in px)\n */\nfunction approxTitleDepth(ax) {\n    var fontSize = ax.title.font.size;\n    var extraLines = (ax.title.text.match(svgTextUtils.BR_TAG_ALL) || []).length;\n    if(ax.title.hasOwnProperty('standoff')) {\n        return extraLines ?\n            fontSize * (CAP_SHIFT + (extraLines * LINE_SPACING)) :\n            fontSize * CAP_SHIFT;\n    } else {\n        return extraLines ?\n            fontSize * (extraLines + 1) * LINE_SPACING :\n            fontSize;\n    }\n}\n\n/**\n * Draw axis title, compute default standoff if necessary\n *\n * @param {DOM element} gd\n * @param {object} ax (full) axis object\n *  - {string} _id\n *  - {string} _name\n *  - {string} side\n *  - {number} title.font.size\n *  - {object} _selections\n *\n *  - {number} _depth\n *  - {number} title.standoff\n *  OR\n *  - {number} linewidth\n *  - {boolean} showticklabels\n */\nfunction drawTitle(gd, ax) {\n    var fullLayout = gd._fullLayout;\n    var axId = ax._id;\n    var axLetter = axId.charAt(0);\n    var fontSize = ax.title.font.size;\n    var titleStandoff;\n\n    if(ax.title.hasOwnProperty('standoff')) {\n        titleStandoff = ax._depth + ax.title.standoff + approxTitleDepth(ax);\n    } else {\n        var isInside = insideTicklabelposition(ax);\n\n        if(ax.type === 'multicategory') {\n            titleStandoff = ax._depth;\n        } else {\n            var offsetBase = 1.5 * fontSize;\n            if(isInside) {\n                offsetBase = 0.5 * fontSize;\n                if(ax.ticks === 'outside') {\n                    offsetBase += ax.ticklen;\n                }\n            }\n            titleStandoff = 10 + offsetBase + (ax.linewidth ? ax.linewidth - 1 : 0);\n        }\n\n        if(!isInside) {\n            if(axLetter === 'x') {\n                titleStandoff += ax.side === 'top' ?\n                    fontSize * (ax.showticklabels ? 1 : 0) :\n                    fontSize * (ax.showticklabels ? 1.5 : 0.5);\n            } else {\n                titleStandoff += ax.side === 'right' ?\n                    fontSize * (ax.showticklabels ? 1 : 0.5) :\n                    fontSize * (ax.showticklabels ? 0.5 : 0);\n            }\n        }\n    }\n\n    var pos = axes.getPxPosition(gd, ax);\n    var transform, x, y;\n\n    if(axLetter === 'x') {\n        x = ax._offset + ax._length / 2;\n        y = (ax.side === 'top') ? pos - titleStandoff : pos + titleStandoff;\n    } else {\n        y = ax._offset + ax._length / 2;\n        x = (ax.side === 'right') ? pos + titleStandoff : pos - titleStandoff;\n        transform = {rotate: '-90', offset: 0};\n    }\n\n    var avoid;\n\n    if(ax.type !== 'multicategory') {\n        var tickLabels = ax._selections[ax._id + 'tick'];\n\n        avoid = {\n            selection: tickLabels,\n            side: ax.side\n        };\n\n        if(tickLabels && tickLabels.node() && tickLabels.node().parentNode) {\n            var translation = Drawing.getTranslate(tickLabels.node().parentNode);\n            avoid.offsetLeft = translation.x;\n            avoid.offsetTop = translation.y;\n        }\n\n        if(ax.title.hasOwnProperty('standoff')) {\n            avoid.pad = 0;\n        }\n    }\n\n    ax._titleStandoff = titleStandoff;\n\n    return Titles.draw(gd, axId + 'title', {\n        propContainer: ax,\n        propName: ax._name + '.title.text',\n        placeholder: fullLayout._dfltTitle[axLetter],\n        avoid: avoid,\n        transform: transform,\n        attributes: {x: x, y: y, 'text-anchor': 'middle'}\n    });\n}\n\naxes.shouldShowZeroLine = function(gd, ax, counterAxis) {\n    var rng = Lib.simpleMap(ax.range, ax.r2l);\n    return (\n        (rng[0] * rng[1] <= 0) &&\n        ax.zeroline &&\n        (ax.type === 'linear' || ax.type === '-') &&\n        !(ax.rangebreaks && ax.maskBreaks(0) === BADNUM) &&\n        (\n            clipEnds(ax, 0) ||\n            !anyCounterAxLineAtZero(gd, ax, counterAxis, rng) ||\n            hasBarsOrFill(gd, ax)\n        )\n    );\n};\n\naxes.clipEnds = function(ax, vals) {\n    return vals.filter(function(d) { return clipEnds(ax, d.x); });\n};\n\nfunction clipEnds(ax, l) {\n    var p = ax.l2p(l);\n    return (p > 1 && p < ax._length - 1);\n}\n\nfunction anyCounterAxLineAtZero(gd, ax, counterAxis, rng) {\n    var mainCounterAxis = counterAxis._mainAxis;\n    if(!mainCounterAxis) return;\n\n    var fullLayout = gd._fullLayout;\n    var axLetter = ax._id.charAt(0);\n    var counterLetter = axes.counterLetter(ax._id);\n\n    var zeroPosition = ax._offset + (\n        ((Math.abs(rng[0]) < Math.abs(rng[1])) === (axLetter === 'x')) ?\n        0 : ax._length\n    );\n\n    function lineNearZero(ax2) {\n        if(!ax2.showline || !ax2.linewidth) return false;\n        var tolerance = Math.max((ax2.linewidth + ax.zerolinewidth) / 2, 1);\n\n        function closeEnough(pos2) {\n            return typeof pos2 === 'number' && Math.abs(pos2 - zeroPosition) < tolerance;\n        }\n\n        if(closeEnough(ax2._mainLinePosition) || closeEnough(ax2._mainMirrorPosition)) {\n            return true;\n        }\n        var linePositions = ax2._linepositions || {};\n        for(var k in linePositions) {\n            if(closeEnough(linePositions[k][0]) || closeEnough(linePositions[k][1])) {\n                return true;\n            }\n        }\n    }\n\n    var plotinfo = fullLayout._plots[counterAxis._mainSubplot];\n    if(!(plotinfo.mainplotinfo || plotinfo).overlays.length) {\n        return lineNearZero(counterAxis, zeroPosition);\n    }\n\n    var counterLetterAxes = axes.list(gd, counterLetter);\n    for(var i = 0; i < counterLetterAxes.length; i++) {\n        var counterAxis2 = counterLetterAxes[i];\n        if(\n            counterAxis2._mainAxis === mainCounterAxis &&\n            lineNearZero(counterAxis2, zeroPosition)\n        ) {\n            return true;\n        }\n    }\n}\n\nfunction hasBarsOrFill(gd, ax) {\n    var fullData = gd._fullData;\n    var subplot = ax._mainSubplot;\n    var axLetter = ax._id.charAt(0);\n\n    for(var i = 0; i < fullData.length; i++) {\n        var trace = fullData[i];\n\n        if(trace.visible === true && (trace.xaxis + trace.yaxis) === subplot) {\n            if(\n                Registry.traceIs(trace, 'bar-like') &&\n                trace.orientation === {x: 'h', y: 'v'}[axLetter]\n            ) return true;\n\n            if(\n                trace.fill &&\n                trace.fill.charAt(trace.fill.length - 1) === axLetter\n            ) return true;\n        }\n    }\n    return false;\n}\n\nfunction selectTickLabel(gTick) {\n    var s = d3.select(gTick);\n    var mj = s.select('.text-math-group');\n    return mj.empty() ? s.select('text') : mj;\n}\n\n/**\n * Find all margin pushers for 2D axes and reserve them for later use\n * Both label and rangeslider automargin calculations happen later so\n * we need to explicitly allow their ids in order to not delete them.\n *\n * TODO: can we pull the actual automargin calls forward to avoid this hack?\n * We're probably also doing multiple redraws in this case, would be faster\n * if we can just do the whole calculation ahead of time and draw once.\n */\naxes.allowAutoMargin = function(gd) {\n    var axList = axes.list(gd, '', true);\n    for(var i = 0; i < axList.length; i++) {\n        var ax = axList[i];\n        if(ax.automargin) {\n            Plots.allowAutoMargin(gd, axAutoMarginID(ax));\n            if(ax.mirror) {\n                Plots.allowAutoMargin(gd, axMirrorAutoMarginID(ax));\n            }\n        }\n        if(Registry.getComponentMethod('rangeslider', 'isVisible')(ax)) {\n            Plots.allowAutoMargin(gd, rangeSliderAutoMarginID(ax));\n        }\n    }\n};\n\nfunction axAutoMarginID(ax) { return ax._id + '.automargin'; }\nfunction axMirrorAutoMarginID(ax) { return axAutoMarginID(ax) + '.mirror'; }\nfunction rangeSliderAutoMarginID(ax) { return ax._id + '.rangeslider'; }\n\n// swap all the presentation attributes of the axes showing these traces\naxes.swap = function(gd, traces) {\n    var axGroups = makeAxisGroups(gd, traces);\n\n    for(var i = 0; i < axGroups.length; i++) {\n        swapAxisGroup(gd, axGroups[i].x, axGroups[i].y);\n    }\n};\n\nfunction makeAxisGroups(gd, traces) {\n    var groups = [];\n    var i, j;\n\n    for(i = 0; i < traces.length; i++) {\n        var groupsi = [];\n        var xi = gd._fullData[traces[i]].xaxis;\n        var yi = gd._fullData[traces[i]].yaxis;\n        if(!xi || !yi) continue; // not a 2D cartesian trace?\n\n        for(j = 0; j < groups.length; j++) {\n            if(groups[j].x.indexOf(xi) !== -1 || groups[j].y.indexOf(yi) !== -1) {\n                groupsi.push(j);\n            }\n        }\n\n        if(!groupsi.length) {\n            groups.push({x: [xi], y: [yi]});\n            continue;\n        }\n\n        var group0 = groups[groupsi[0]];\n        var groupj;\n\n        if(groupsi.length > 1) {\n            for(j = 1; j < groupsi.length; j++) {\n                groupj = groups[groupsi[j]];\n                mergeAxisGroups(group0.x, groupj.x);\n                mergeAxisGroups(group0.y, groupj.y);\n            }\n        }\n        mergeAxisGroups(group0.x, [xi]);\n        mergeAxisGroups(group0.y, [yi]);\n    }\n\n    return groups;\n}\n\nfunction mergeAxisGroups(intoSet, fromSet) {\n    for(var i = 0; i < fromSet.length; i++) {\n        if(intoSet.indexOf(fromSet[i]) === -1) intoSet.push(fromSet[i]);\n    }\n}\n\nfunction swapAxisGroup(gd, xIds, yIds) {\n    var xFullAxes = [];\n    var yFullAxes = [];\n    var layout = gd.layout;\n    var i, j;\n\n    for(i = 0; i < xIds.length; i++) xFullAxes.push(axes.getFromId(gd, xIds[i]));\n    for(i = 0; i < yIds.length; i++) yFullAxes.push(axes.getFromId(gd, yIds[i]));\n\n    var allAxKeys = Object.keys(axAttrs);\n\n    var noSwapAttrs = [\n        'anchor', 'domain', 'overlaying', 'position', 'side', 'tickangle', 'editType'\n    ];\n    var numericTypes = ['linear', 'log'];\n\n    for(i = 0; i < allAxKeys.length; i++) {\n        var keyi = allAxKeys[i];\n        var xVal = xFullAxes[0][keyi];\n        var yVal = yFullAxes[0][keyi];\n        var allEqual = true;\n        var coerceLinearX = false;\n        var coerceLinearY = false;\n        if(keyi.charAt(0) === '_' || typeof xVal === 'function' ||\n                noSwapAttrs.indexOf(keyi) !== -1) {\n            continue;\n        }\n        for(j = 1; j < xFullAxes.length && allEqual; j++) {\n            var xVali = xFullAxes[j][keyi];\n            if(keyi === 'type' && numericTypes.indexOf(xVal) !== -1 &&\n                    numericTypes.indexOf(xVali) !== -1 && xVal !== xVali) {\n                // type is special - if we find a mixture of linear and log,\n                // coerce them all to linear on flipping\n                coerceLinearX = true;\n            } else if(xVali !== xVal) allEqual = false;\n        }\n        for(j = 1; j < yFullAxes.length && allEqual; j++) {\n            var yVali = yFullAxes[j][keyi];\n            if(keyi === 'type' && numericTypes.indexOf(yVal) !== -1 &&\n                    numericTypes.indexOf(yVali) !== -1 && yVal !== yVali) {\n                // type is special - if we find a mixture of linear and log,\n                // coerce them all to linear on flipping\n                coerceLinearY = true;\n            } else if(yFullAxes[j][keyi] !== yVal) allEqual = false;\n        }\n        if(allEqual) {\n            if(coerceLinearX) layout[xFullAxes[0]._name].type = 'linear';\n            if(coerceLinearY) layout[yFullAxes[0]._name].type = 'linear';\n            swapAxisAttrs(layout, keyi, xFullAxes, yFullAxes, gd._fullLayout._dfltTitle);\n        }\n    }\n\n    // now swap x&y for any annotations anchored to these x & y\n    for(i = 0; i < gd._fullLayout.annotations.length; i++) {\n        var ann = gd._fullLayout.annotations[i];\n        if(xIds.indexOf(ann.xref) !== -1 &&\n                yIds.indexOf(ann.yref) !== -1) {\n            Lib.swapAttrs(layout.annotations[i], ['?']);\n        }\n    }\n}\n\nfunction swapAxisAttrs(layout, key, xFullAxes, yFullAxes, dfltTitle) {\n    // in case the value is the default for either axis,\n    // look at the first axis in each list and see if\n    // this key's value is undefined\n    var np = Lib.nestedProperty;\n    var xVal = np(layout[xFullAxes[0]._name], key).get();\n    var yVal = np(layout[yFullAxes[0]._name], key).get();\n    var i;\n\n    if(key === 'title') {\n        // special handling of placeholder titles\n        if(xVal && xVal.text === dfltTitle.x) {\n            xVal.text = dfltTitle.y;\n        }\n        if(yVal && yVal.text === dfltTitle.y) {\n            yVal.text = dfltTitle.x;\n        }\n    }\n\n    for(i = 0; i < xFullAxes.length; i++) {\n        np(layout, xFullAxes[i]._name + '.' + key).set(yVal);\n    }\n    for(i = 0; i < yFullAxes.length; i++) {\n        np(layout, yFullAxes[i]._name + '.' + key).set(xVal);\n    }\n}\n\nfunction isAngular(ax) {\n    return ax._id === 'angularaxis';\n}\n\nfunction moveOutsideBreak(v, ax) {\n    var len = ax._rangebreaks.length;\n    for(var k = 0; k < len; k++) {\n        var brk = ax._rangebreaks[k];\n        if(v >= brk.min && v < brk.max) {\n            return brk.max;\n        }\n    }\n    return v;\n}\n\nfunction insideTicklabelposition(ax) {\n    return ((ax.ticklabelposition || '').indexOf('inside') !== -1);\n}\n\nfunction hideCounterAxisInsideTickLabels(ax, opts) {\n    if(insideTicklabelposition(ax._anchorAxis || {})) {\n        if(ax._hideCounterAxisInsideTickLabels) {\n            ax._hideCounterAxisInsideTickLabels(opts);\n        }\n    }\n}\n\nfunction incrementShift(ax, shiftVal, axShifts, normalize) {\n    // Need to set 'overlay' for anchored axis\n    var overlay = ((ax.anchor !== 'free') && ((ax.overlaying === undefined) || (ax.overlaying === false))) ? ax._id : ax.overlaying;\n    var shiftValAdj;\n    if(normalize) {\n        shiftValAdj = ax.side === 'right' ? shiftVal : -shiftVal;\n    } else {\n        shiftValAdj = shiftVal;\n    }\n    if(!(overlay in axShifts)) {\n        axShifts[overlay] = {};\n    }\n    if(!(ax.side in axShifts[overlay])) {\n        axShifts[overlay][ax.side] = 0;\n    }\n    axShifts[overlay][ax.side] += shiftValAdj;\n}\n\nfunction setShiftVal(ax, axShifts) {\n    return ax.autoshift ?\n        axShifts[ax.overlaying][ax.side] :\n        (ax.shift || 0);\n}\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\n\nvar Lib = require('../../lib');\nvar BADNUM = require('../../constants/numerical').BADNUM;\n\nvar isArrayOrTypedArray = Lib.isArrayOrTypedArray;\nvar isDateTime = Lib.isDateTime;\nvar cleanNumber = Lib.cleanNumber;\nvar round = Math.round;\n\nmodule.exports = function autoType(array, calendar, opts) {\n    var a = array;\n\n    var noMultiCategory = opts.noMultiCategory;\n    if(isArrayOrTypedArray(a) && !a.length) return '-';\n    if(!noMultiCategory && multiCategory(a)) return 'multicategory';\n    if(noMultiCategory && Array.isArray(a[0])) { // no need to flat typed arrays here\n        var b = [];\n        for(var i = 0; i < a.length; i++) {\n            if(isArrayOrTypedArray(a[i])) {\n                for(var j = 0; j < a[i].length; j++) {\n                    b.push(a[i][j]);\n                }\n            }\n        }\n        a = b;\n    }\n\n    if(moreDates(a, calendar)) return 'date';\n\n    var convertNumeric = opts.autotypenumbers !== 'strict'; // compare against strict, just in case autotypenumbers was not provided in opts\n    if(category(a, convertNumeric)) return 'category';\n    if(linearOK(a, convertNumeric)) return 'linear';\n\n    return '-';\n};\n\nfunction hasTypeNumber(v, convertNumeric) {\n    return convertNumeric ? isNumeric(v) : typeof v === 'number';\n}\n\n// is there at least one number in array? If not, we should leave\n// ax.type empty so it can be autoset later\nfunction linearOK(a, convertNumeric) {\n    var len = a.length;\n\n    for(var i = 0; i < len; i++) {\n        if(hasTypeNumber(a[i], convertNumeric)) return true;\n    }\n\n    return false;\n}\n\n// does the array a have mostly dates rather than numbers?\n// note: some values can be neither (such as blanks, text)\n// 2- or 4-digit integers can be both, so require twice as many\n// dates as non-dates, to exclude cases with mostly 2 & 4 digit\n// numbers and a few dates\n// as with categories, consider DISTINCT values only.\nfunction moreDates(a, calendar) {\n    var len = a.length;\n\n    var inc = getIncrement(len);\n    var dats = 0;\n    var nums = 0;\n    var seen = {};\n\n    for(var f = 0; f < len; f += inc) {\n        var i = round(f);\n        var ai = a[i];\n        var stri = String(ai);\n        if(seen[stri]) continue;\n        seen[stri] = 1;\n\n        if(isDateTime(ai, calendar)) dats++;\n        if(isNumeric(ai)) nums++;\n    }\n\n    return dats > nums * 2;\n}\n\n// return increment to test at most 1000 points, evenly spaced\nfunction getIncrement(len) {\n    return Math.max(1, (len - 1) / 1000);\n}\n\n// are the (x,y)-values in gd.data mostly text?\n// require twice as many DISTINCT categories as distinct numbers\nfunction category(a, convertNumeric) {\n    var len = a.length;\n\n    var inc = getIncrement(len);\n    var nums = 0;\n    var cats = 0;\n    var seen = {};\n\n    for(var f = 0; f < len; f += inc) {\n        var i = round(f);\n        var ai = a[i];\n        var stri = String(ai);\n        if(seen[stri]) continue;\n        seen[stri] = 1;\n\n        var t = typeof ai;\n        if(t === 'boolean') cats++;\n        else if(convertNumeric ? cleanNumber(ai) !== BADNUM : t === 'number') nums++;\n        else if(t === 'string') cats++;\n    }\n\n    return cats > nums * 2;\n}\n\n// very-loose requirements for multicategory,\n// trace modules that should never auto-type to multicategory\n// should be declared with 'noMultiCategory'\nfunction multiCategory(a) {\n    return isArrayOrTypedArray(a[0]) && isArrayOrTypedArray(a[1]);\n}\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\n\nvar Registry = require('../../registry');\nvar Lib = require('../../lib');\nvar Template = require('../../plot_api/plot_template');\n\nvar handleArrayContainerDefaults = require('../array_container_defaults');\n\nvar layoutAttributes = require('./layout_attributes');\nvar handleTickValueDefaults = require('./tick_value_defaults');\nvar handleTickMarkDefaults = require('./tick_mark_defaults');\nvar handleTickLabelDefaults = require('./tick_label_defaults');\nvar handlePrefixSuffixDefaults = require('./prefix_suffix_defaults');\nvar handleCategoryOrderDefaults = require('./category_order_defaults');\nvar handleLineGridDefaults = require('./line_grid_defaults');\nvar handleRangeDefaults = require('./range_defaults');\nvar setConvert = require('./set_convert');\n\nvar DAY_OF_WEEK = require('./constants').WEEKDAY_PATTERN;\nvar HOUR = require('./constants').HOUR_PATTERN;\n\n/**\n * options: object containing:\n *\n *  letter: 'x' or 'y'\n *  title: name of the axis (ie 'Colorbar') to go in default title\n *  font: the default font to inherit\n *  outerTicks: boolean, should ticks default to outside?\n *  showGrid: boolean, should gridlines be shown by default?\n *  noHover: boolean, this axis doesn't support hover effects?\n *  noTickson: boolean, this axis doesn't support 'tickson'\n *  data: the plot data, used to manage categories\n *  bgColor: the plot background color, to calculate default gridline colors\n *  calendar:\n *  splomStash:\n *  visibleDflt: boolean\n *  reverseDflt: boolean\n *  automargin: boolean\n */\nmodule.exports = function handleAxisDefaults(containerIn, containerOut, coerce, options, layoutOut) {\n    var letter = options.letter;\n    var font = options.font || {};\n    var splomStash = options.splomStash || {};\n\n    var visible = coerce('visible', !options.visibleDflt);\n\n    var axTemplate = containerOut._template || {};\n    var axType = containerOut.type || axTemplate.type || '-';\n\n    var ticklabelmode;\n    if(axType === 'date') {\n        var handleCalendarDefaults = Registry.getComponentMethod('calendars', 'handleDefaults');\n        handleCalendarDefaults(containerIn, containerOut, 'calendar', options.calendar);\n\n        if(!options.noTicklabelmode) {\n            ticklabelmode = coerce('ticklabelmode');\n        }\n    }\n\n    var ticklabelposition = '';\n    if(!options.noTicklabelposition || axType === 'multicategory') {\n        ticklabelposition = Lib.coerce(containerIn, containerOut, {\n            ticklabelposition: {\n                valType: 'enumerated',\n                dflt: 'outside',\n                values: ticklabelmode === 'period' ? ['outside', 'inside'] :\n                letter === 'x' ? [\n                    'outside', 'inside',\n                    'outside left', 'inside left',\n                    'outside right', 'inside right'\n                ] : [\n                    'outside', 'inside',\n                    'outside top', 'inside top',\n                    'outside bottom', 'inside bottom'\n                ]\n            }\n        }, 'ticklabelposition');\n    }\n\n    if(!options.noTicklabeloverflow) {\n        coerce('ticklabeloverflow',\n            ticklabelposition.indexOf('inside') !== -1 ?\n                'hide past domain' :\n            axType === 'category' ||\n            axType === 'multicategory' ?\n                'allow' :\n                'hide past div'\n        );\n    }\n\n    setConvert(containerOut, layoutOut);\n\n    handleRangeDefaults(containerIn, containerOut, coerce, options);\n\n    handleCategoryOrderDefaults(containerIn, containerOut, coerce, options);\n\n    if(axType !== 'category' && !options.noHover) coerce('hoverformat');\n\n    var dfltColor = coerce('color');\n    // if axis.color was provided, use it for fonts too; otherwise,\n    // inherit from global font color in case that was provided.\n    // Compare to dflt rather than to containerIn, so we can provide color via\n    // template too.\n    var dfltFontColor = (dfltColor !== layoutAttributes.color.dflt) ? dfltColor : font.color;\n    // try to get default title from splom trace, fallback to graph-wide value\n    var dfltTitle = splomStash.label || layoutOut._dfltTitle[letter];\n\n    handlePrefixSuffixDefaults(containerIn, containerOut, coerce, axType, options);\n    if(!visible) return containerOut;\n\n    coerce('title.text', dfltTitle);\n    Lib.coerceFont(coerce, 'title.font', {\n        family: font.family,\n        size: Lib.bigFont(font.size),\n        color: dfltFontColor\n    });\n\n    // major ticks\n    handleTickValueDefaults(containerIn, containerOut, coerce, axType);\n\n    var hasMinor = options.hasMinor;\n    if(hasMinor) {\n        // minor ticks\n        Template.newContainer(containerOut, 'minor');\n        handleTickValueDefaults(containerIn, containerOut, coerce, axType, { isMinor: true });\n    }\n\n    handleTickLabelDefaults(containerIn, containerOut, coerce, axType, options);\n\n    // major and minor ticks\n    handleTickMarkDefaults(containerIn, containerOut, coerce, options);\n    if(hasMinor) {\n        var keepIsMinor = options.isMinor;\n        options.isMinor = true;\n        handleTickMarkDefaults(containerIn, containerOut, coerce, options);\n        options.isMinor = keepIsMinor;\n    }\n\n    handleLineGridDefaults(containerIn, containerOut, coerce, {\n        dfltColor: dfltColor,\n        bgColor: options.bgColor,\n        showGrid: options.showGrid,\n        hasMinor: hasMinor,\n        attributes: layoutAttributes\n    });\n\n    // delete minor when no minor ticks or gridlines\n    if(\n        hasMinor &&\n        !containerOut.minor.ticks &&\n        !containerOut.minor.showgrid\n    ) {\n        delete containerOut.minor;\n    }\n\n    // mirror\n    if(containerOut.showline || containerOut.ticks) coerce('mirror');\n\n    var isMultiCategory = axType === 'multicategory';\n\n    if(!options.noTickson &&\n        (axType === 'category' || isMultiCategory) &&\n        (containerOut.ticks || containerOut.showgrid)\n    ) {\n        var ticksonDflt;\n        if(isMultiCategory) ticksonDflt = 'boundaries';\n        var tickson = coerce('tickson', ticksonDflt);\n        if(tickson === 'boundaries') {\n            delete containerOut.ticklabelposition;\n        }\n    }\n\n    if(isMultiCategory) {\n        var showDividers = coerce('showdividers');\n        if(showDividers) {\n            coerce('dividercolor');\n            coerce('dividerwidth');\n        }\n    }\n\n    if(axType === 'date') {\n        handleArrayContainerDefaults(containerIn, containerOut, {\n            name: 'rangebreaks',\n            inclusionAttr: 'enabled',\n            handleItemDefaults: rangebreaksDefaults\n        });\n\n        if(!containerOut.rangebreaks.length) {\n            delete containerOut.rangebreaks;\n        } else {\n            for(var k = 0; k < containerOut.rangebreaks.length; k++) {\n                if(containerOut.rangebreaks[k].pattern === DAY_OF_WEEK) {\n                    containerOut._hasDayOfWeekBreaks = true;\n                    break;\n                }\n            }\n\n            setConvert(containerOut, layoutOut);\n\n            if(layoutOut._has('scattergl') || layoutOut._has('splom')) {\n                for(var i = 0; i < options.data.length; i++) {\n                    var trace = options.data[i];\n                    if(trace.type === 'scattergl' || trace.type === 'splom') {\n                        trace.visible = false;\n                        Lib.warn(trace.type +\n                            ' traces do not work on axes with rangebreaks.' +\n                            ' Setting trace ' + trace.index + ' to `visible: false`.');\n                    }\n                }\n            }\n        }\n    }\n\n    return containerOut;\n};\n\nfunction rangebreaksDefaults(itemIn, itemOut, containerOut) {\n    function coerce(attr, dflt) {\n        return Lib.coerce(itemIn, itemOut, layoutAttributes.rangebreaks, attr, dflt);\n    }\n\n    var enabled = coerce('enabled');\n\n    if(enabled) {\n        var bnds = coerce('bounds');\n        if(bnds && bnds.length >= 2) {\n            var dfltPattern = '';\n            var i, q;\n            if(bnds.length === 2) {\n                for(i = 0; i < 2; i++) {\n                    q = indexOfDay(bnds[i]);\n                    if(q) {\n                        dfltPattern = DAY_OF_WEEK;\n                        break;\n                    }\n                }\n            }\n            var pattern = coerce('pattern', dfltPattern);\n            if(pattern === DAY_OF_WEEK) {\n                for(i = 0; i < 2; i++) {\n                    q = indexOfDay(bnds[i]);\n                    if(q) {\n                        // convert to integers i.e 'Sunday' --> 0\n                        itemOut.bounds[i] = bnds[i] = q - 1;\n                    }\n                }\n            }\n            if(pattern) {\n                // ensure types and ranges\n                for(i = 0; i < 2; i++) {\n                    q = bnds[i];\n                    switch(pattern) {\n                        case DAY_OF_WEEK :\n                            if(!isNumeric(q)) {\n                                itemOut.enabled = false;\n                                return;\n                            }\n                            q = +q;\n\n                            if(\n                                q !== Math.floor(q) || // don't accept fractional days for mow\n                                q < 0 || q >= 7\n                            ) {\n                                itemOut.enabled = false;\n                                return;\n                            }\n                            // use number\n                            itemOut.bounds[i] = bnds[i] = q;\n                            break;\n\n                        case HOUR :\n                            if(!isNumeric(q)) {\n                                itemOut.enabled = false;\n                                return;\n                            }\n                            q = +q;\n\n                            if(q < 0 || q > 24) { // accept 24\n                                itemOut.enabled = false;\n                                return;\n                            }\n                            // use number\n                            itemOut.bounds[i] = bnds[i] = q;\n                            break;\n                    }\n                }\n            }\n\n            if(containerOut.autorange === false) {\n                var rng = containerOut.range;\n\n                // if bounds are bigger than the (set) range, disable break\n                if(rng[0] < rng[1]) {\n                    if(bnds[0] < rng[0] && bnds[1] > rng[1]) {\n                        itemOut.enabled = false;\n                        return;\n                    }\n                } else if(bnds[0] > rng[0] && bnds[1] < rng[1]) {\n                    itemOut.enabled = false;\n                    return;\n                }\n            }\n        } else {\n            var values = coerce('values');\n\n            if(values && values.length) {\n                coerce('dvalue');\n            } else {\n                itemOut.enabled = false;\n                return;\n            }\n        }\n    }\n}\n\n// these numbers are one more than what bounds would be mapped to\nvar dayStrToNum = {\n    sun: 1,\n    mon: 2,\n    tue: 3,\n    wed: 4,\n    thu: 5,\n    fri: 6,\n    sat: 7\n};\n\nfunction indexOfDay(v) {\n    if(typeof v !== 'string') return;\n    return dayStrToNum[\n        v.substr(0, 3).toLowerCase()\n    ];\n}\n","'use strict';\n\nvar docs = require('../../constants/docs');\nvar FORMAT_LINK = docs.FORMAT_LINK;\nvar DATE_FORMAT_LINK = docs.DATE_FORMAT_LINK;\n\nfunction axisHoverFormat(x, noDates) {\n    return {\n        valType: 'string',\n        dflt: '',\n        editType: 'none',\n        description: (\n            noDates ? descriptionOnlyNumbers : descriptionWithDates\n        )('hover text', x) + [\n            'By default the values are formatted using ' + (\n                noDates ?\n                    'generic number format' :\n                    ('`' + x + 'axis.hoverformat`')\n            ) + '.',\n        ].join(' ')\n    };\n}\n\nfunction descriptionOnlyNumbers(label, x) {\n    return [\n        'Sets the ' + label + ' formatting rule' + (x ? 'for `' + x + '` ' : ''),\n        'using d3 formatting mini-languages',\n        'which are very similar to those in Python. For numbers, see: ' + FORMAT_LINK + '.'\n    ].join(' ');\n}\n\nfunction descriptionWithDates(label, x) {\n    return descriptionOnlyNumbers(label, x) + [\n        ' And for dates see: ' + DATE_FORMAT_LINK + '.',\n        'We add two items to d3\\'s date formatter:',\n        '*%h* for half of the year as a decimal number as well as',\n        '*%{n}f* for fractional seconds',\n        'with n digits. For example, *2016-10-13 09:15:23.456* with tickformat',\n        '*%H~%M~%S.%2f* would display *09~15~23.46*'\n    ].join(' ');\n}\n\nmodule.exports = {\n    axisHoverFormat: axisHoverFormat,\n    descriptionOnlyNumbers: descriptionOnlyNumbers,\n    descriptionWithDates: descriptionWithDates\n};\n","'use strict';\n\nvar Registry = require('../../registry');\n\nvar constants = require('./constants');\n\n\n// convert between axis names (xaxis, xaxis2, etc, elements of gd.layout)\n// and axis id's (x, x2, etc). Would probably have ditched 'xaxis'\n// completely in favor of just 'x' if it weren't ingrained in the API etc.\nexports.id2name = function id2name(id) {\n    if(typeof id !== 'string' || !id.match(constants.AX_ID_PATTERN)) return;\n    var axNum = id.split(' ')[0].substr(1);\n    if(axNum === '1') axNum = '';\n    return id.charAt(0) + 'axis' + axNum;\n};\n\nexports.name2id = function name2id(name) {\n    if(!name.match(constants.AX_NAME_PATTERN)) return;\n    var axNum = name.substr(5);\n    if(axNum === '1') axNum = '';\n    return name.charAt(0) + axNum;\n};\n\n/*\n * Cleans up the number of an axis, e.g., 'x002'->'x2', 'x0'->'x', 'x1' -> 'x',\n * etc.\n * If domainId is true, then id could be a domain reference and if it is, the\n * ' domain' part is kept at the end of the axis ID string.\n */\nexports.cleanId = function cleanId(id, axLetter, domainId) {\n    var domainTest = /( domain)$/.test(id);\n    if(typeof id !== 'string' || !id.match(constants.AX_ID_PATTERN)) return;\n    if(axLetter && id.charAt(0) !== axLetter) return;\n    if(domainTest && (!domainId)) return;\n    var axNum = id.split(' ')[0].substr(1).replace(/^0+/, '');\n    if(axNum === '1') axNum = '';\n    return id.charAt(0) + axNum + (domainTest && domainId ? ' domain' : '');\n};\n\n// get all axis objects, as restricted in listNames\nexports.list = function(gd, axLetter, only2d) {\n    var fullLayout = gd._fullLayout;\n    if(!fullLayout) return [];\n\n    var idList = exports.listIds(gd, axLetter);\n    var out = new Array(idList.length);\n    var i;\n\n    for(i = 0; i < idList.length; i++) {\n        var idi = idList[i];\n        out[i] = fullLayout[idi.charAt(0) + 'axis' + idi.substr(1)];\n    }\n\n    if(!only2d) {\n        var sceneIds3D = fullLayout._subplots.gl3d || [];\n\n        for(i = 0; i < sceneIds3D.length; i++) {\n            var scene = fullLayout[sceneIds3D[i]];\n\n            if(axLetter) out.push(scene[axLetter + 'axis']);\n            else out.push(scene.xaxis, scene.yaxis, scene.zaxis);\n        }\n    }\n\n    return out;\n};\n\n// get all axis ids, optionally restricted by letter\n// this only makes sense for 2d axes\nexports.listIds = function(gd, axLetter) {\n    var fullLayout = gd._fullLayout;\n    if(!fullLayout) return [];\n\n    var subplotLists = fullLayout._subplots;\n    if(axLetter) return subplotLists[axLetter + 'axis'];\n    return subplotLists.xaxis.concat(subplotLists.yaxis);\n};\n\n// get an axis object from its id 'x','x2' etc\n// optionally, id can be a subplot (ie 'x2y3') and type gets x or y from it\nexports.getFromId = function(gd, id, type) {\n    var fullLayout = gd._fullLayout;\n    // remove \"domain\" suffix\n    id = ((id === undefined) || (typeof(id) !== 'string')) ? id : id.replace(' domain', '');\n\n    if(type === 'x') id = id.replace(/y[0-9]*/, '');\n    else if(type === 'y') id = id.replace(/x[0-9]*/, '');\n\n    return fullLayout[exports.id2name(id)];\n};\n\n// get an axis object of specified type from the containing trace\nexports.getFromTrace = function(gd, fullTrace, type) {\n    var fullLayout = gd._fullLayout;\n    var ax = null;\n\n    if(Registry.traceIs(fullTrace, 'gl3d')) {\n        var scene = fullTrace.scene;\n        if(scene.substr(0, 5) === 'scene') {\n            ax = fullLayout[scene][type + 'axis'];\n        }\n    } else {\n        ax = exports.getFromId(gd, fullTrace[type + 'axis'] || type);\n    }\n\n    return ax;\n};\n\n// sort x, x2, x10, y, y2, y10...\nexports.idSort = function(id1, id2) {\n    var letter1 = id1.charAt(0);\n    var letter2 = id2.charAt(0);\n    if(letter1 !== letter2) return letter1 > letter2 ? 1 : -1;\n    return +(id1.substr(1) || 1) - +(id2.substr(1) || 1);\n};\n\n/*\n * An axis reference (e.g., the contents at the 'xref' key of an object) might\n * have extra information appended. Extract the axis ID only.\n *\n * ar: the axis reference string\n *\n */\nexports.ref2id = function(ar) {\n    // This assumes ar has been coerced via coerceRef, and uses the shortcut of\n    // checking if the first letter matches [xyz] to determine if it should\n    // return the axis ID. Otherwise it returns false.\n    return (/^[xyz]/.test(ar)) ? ar.split(' ')[0] : false;\n};\n\nfunction isFound(axId, list) {\n    if(list && list.length) {\n        for(var i = 0; i < list.length; i++) {\n            if(list[i][axId]) return true;\n        }\n    }\n    return false;\n}\n\nexports.isLinked = function(fullLayout, axId) {\n    return (\n        isFound(axId, fullLayout._axisMatchGroups) ||\n        isFound(axId, fullLayout._axisConstraintGroups)\n    );\n};\n","'use strict';\n\nvar isTypedArraySpec = require('../../lib/array').isTypedArraySpec;\n\nfunction findCategories(ax, opts) {\n    var dataAttr = opts.dataAttr || ax._id.charAt(0);\n    var lookup = {};\n    var axData;\n    var i, j;\n\n    if(opts.axData) {\n        // non-x/y case\n        axData = opts.axData;\n    } else {\n        // x/y case\n        axData = [];\n        for(i = 0; i < opts.data.length; i++) {\n            var trace = opts.data[i];\n            if(trace[dataAttr + 'axis'] === ax._id) {\n                axData.push(trace);\n            }\n        }\n    }\n\n    for(i = 0; i < axData.length; i++) {\n        var vals = axData[i][dataAttr];\n        for(j = 0; j < vals.length; j++) {\n            var v = vals[j];\n            if(v !== null && v !== undefined) {\n                lookup[v] = 1;\n            }\n        }\n    }\n\n    return Object.keys(lookup);\n}\n\n/**\n * Fills in category* default and initial categories.\n *\n * @param {object} containerIn : input axis object\n * @param {object} containerOut : full axis object\n * @param {function} coerce : Lib.coerce fn wrapper\n * @param {object} opts :\n *   - data {array} : (full) data trace\n * OR\n *   - axData {array} : (full) data associated with axis being coerced here\n *   - dataAttr {string} : attribute name corresponding to coordinate array\n */\nmodule.exports = function handleCategoryOrderDefaults(containerIn, containerOut, coerce, opts) {\n    if(containerOut.type !== 'category') return;\n\n    var arrayIn = containerIn.categoryarray;\n    var isValidArray = (Array.isArray(arrayIn) && arrayIn.length > 0) ||\n        isTypedArraySpec(arrayIn);\n\n    // override default 'categoryorder' value when non-empty array is supplied\n    var orderDefault;\n    if(isValidArray) orderDefault = 'array';\n\n    var order = coerce('categoryorder', orderDefault);\n    var array;\n\n    // coerce 'categoryarray' only in array order case\n    if(order === 'array') {\n        array = coerce('categoryarray');\n    }\n\n    // cannot set 'categoryorder' to 'array' with an invalid 'categoryarray'\n    if(!isValidArray && order === 'array') {\n        order = containerOut.categoryorder = 'trace';\n    }\n\n    // set up things for makeCalcdata\n    if(order === 'trace') {\n        containerOut._initialCategories = [];\n    } else if(order === 'array') {\n        containerOut._initialCategories = array.slice();\n    } else {\n        array = findCategories(containerOut, opts).sort();\n        if(order === 'category ascending') {\n            containerOut._initialCategories = array;\n        } else if(order === 'category descending') {\n            containerOut._initialCategories = array.reverse();\n        }\n    }\n};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\nvar Lib = require('../../lib');\nvar constants = require('../../constants/numerical');\nvar ONEDAY = constants.ONEDAY;\nvar ONEWEEK = constants.ONEWEEK;\n\n/**\n * Return a validated dtick value for this axis\n *\n * @param {any} dtick: the candidate dtick. valid values are numbers and strings,\n *     and further constrained depending on the axis type.\n * @param {string} axType: the axis type\n */\nexports.dtick = function(dtick, axType) {\n    var isLog = axType === 'log';\n    var isDate = axType === 'date';\n    var isCat = axType === 'category';\n    var dtickDflt = isDate ? ONEDAY : 1;\n\n    if(!dtick) return dtickDflt;\n\n    if(isNumeric(dtick)) {\n        dtick = Number(dtick);\n        if(dtick <= 0) return dtickDflt;\n        if(isCat) {\n            // category dtick must be positive integers\n            return Math.max(1, Math.round(dtick));\n        }\n        if(isDate) {\n            // date dtick must be at least 0.1ms (our current precision)\n            return Math.max(0.1, dtick);\n        }\n        return dtick;\n    }\n\n    if(typeof dtick !== 'string' || !(isDate || isLog)) {\n        return dtickDflt;\n    }\n\n    var prefix = dtick.charAt(0);\n    var dtickNum = dtick.substr(1);\n    dtickNum = isNumeric(dtickNum) ? Number(dtickNum) : 0;\n\n    if((dtickNum <= 0) || !(\n            // \"M<n>\" gives ticks every (integer) n months\n            (isDate && prefix === 'M' && dtickNum === Math.round(dtickNum)) ||\n            // \"L<f>\" gives ticks linearly spaced in data (not in position) every (float) f\n            (isLog && prefix === 'L') ||\n            // \"D1\" gives powers of 10 with all small digits between, \"D2\" gives only 2 and 5\n            (isLog && prefix === 'D' && (dtickNum === 1 || dtickNum === 2))\n        )) {\n        return dtickDflt;\n    }\n\n    return dtick;\n};\n\n/**\n * Return a validated tick0 for this axis\n *\n * @param {any} tick0: the candidate tick0. Valid values are numbers and strings,\n *     further constrained depending on the axis type\n * @param {string} axType: the axis type\n * @param {string} calendar: for date axes, the calendar to validate/convert with\n * @param {any} dtick: an already valid dtick. Only used for D1 and D2 log dticks,\n *     which do not support tick0 at all.\n */\nexports.tick0 = function(tick0, axType, calendar, dtick) {\n    if(axType === 'date') {\n        return Lib.cleanDate(tick0,\n            Lib.dateTick0(calendar, (dtick % ONEWEEK === 0) ? 1 : 0)\n        );\n    }\n    if(dtick === 'D1' || dtick === 'D2') {\n        // D1 and D2 modes ignore tick0 entirely\n        return undefined;\n    }\n    // Aside from date axes, tick0 must be numeric\n    return isNumeric(tick0) ? Number(tick0) : 0;\n};\n","'use strict';\n\nvar counterRegex = require('../../lib/regex').counter;\n\nmodule.exports = {\n    idRegex: {\n        x: counterRegex('x', '( domain)?'),\n        y: counterRegex('y', '( domain)?')\n    },\n\n    attrRegex: counterRegex('[xy]axis'),\n\n    // axis match regular expression\n    xAxisMatch: counterRegex('xaxis'),\n    yAxisMatch: counterRegex('yaxis'),\n\n    // pattern matching axis ids and names\n    // note that this is more permissive than counterRegex, as\n    // id2name, name2id, and cleanId accept \"x1\" etc\n    AX_ID_PATTERN: /^[xyz][0-9]*( domain)?$/,\n    AX_NAME_PATTERN: /^[xyz]axis[0-9]*$/,\n\n    // and for 2D subplots\n    SUBPLOT_PATTERN: /^x([0-9]*)y([0-9]*)$/,\n\n    HOUR_PATTERN: 'hour',\n    WEEKDAY_PATTERN: 'day of week',\n\n    // pixels to move mouse before you stop clamping to starting point\n    MINDRAG: 8,\n\n    // smallest dimension allowed for a zoombox\n    MINZOOM: 20,\n\n    // width of axis drag regions\n    DRAGGERSIZE: 20,\n\n    // delay before a redraw (relayout) after smooth panning and zooming\n    REDRAWDELAY: 50,\n\n    // last resort axis ranges for x and y axes if we have no data\n    DFLTRANGEX: [-1, 6],\n    DFLTRANGEY: [-1, 4],\n\n    // Layers to keep trace types in the right order\n    // N.B. each  'unique' plot method must have its own layer\n    traceLayerClasses: [\n        'imagelayer',\n        'heatmaplayer',\n        'contourcarpetlayer', 'contourlayer',\n        'funnellayer', 'waterfalllayer', 'barlayer',\n        'carpetlayer',\n        'violinlayer',\n        'boxlayer',\n        'ohlclayer',\n        'scattercarpetlayer', 'scatterlayer'\n    ],\n\n    clipOnAxisFalseQuery: [\n        '.scatterlayer',\n        '.barlayer',\n        '.funnellayer',\n        '.waterfalllayer'\n    ],\n\n    layerValue2layerClass: {\n        'above traces': 'above',\n        'below traces': 'below'\n    }\n};\n","'use strict';\n\nvar Lib = require('../../lib');\n\nvar autorange = require('./autorange');\nvar id2name = require('./axis_ids').id2name;\nvar layoutAttributes = require('./layout_attributes');\nvar scaleZoom = require('./scale_zoom');\nvar setConvert = require('./set_convert');\n\nvar ALMOST_EQUAL = require('../../constants/numerical').ALMOST_EQUAL;\nvar FROM_BL = require('../../constants/alignment').FROM_BL;\n\nexports.handleDefaults = function(layoutIn, layoutOut, opts) {\n    var axIds = opts.axIds;\n    var axHasImage = opts.axHasImage;\n\n    // sets of axes linked by `scaleanchor` OR `matches` along with the\n    // scaleratios compounded together, populated in handleConstraintDefaults\n    var constraintGroups = layoutOut._axisConstraintGroups = [];\n    // similar to _axisConstraintGroups, but only matching axes\n    var matchGroups = layoutOut._axisMatchGroups = [];\n\n    var i, group, axId, axName, axIn, axOut, attr, val;\n\n    for(i = 0; i < axIds.length; i++) {\n        axName = id2name(axIds[i]);\n        axIn = layoutIn[axName];\n        axOut = layoutOut[axName];\n\n        handleOneAxDefaults(axIn, axOut, {\n            axIds: axIds,\n            layoutOut: layoutOut,\n            hasImage: axHasImage[axName]\n        });\n    }\n\n    // save matchGroup on each matching axis\n    function stash(groups, stashAttr) {\n        for(i = 0; i < groups.length; i++) {\n            group = groups[i];\n            for(axId in group) {\n                layoutOut[id2name(axId)][stashAttr] = group;\n            }\n        }\n    }\n    stash(matchGroups, '_matchGroup');\n\n    // If any axis in a constraint group is fixedrange, they all get fixed\n    // This covers matches axes, as they're now in the constraintgroup too\n    // and have not yet been removed (if the group is *only* matching)\n    for(i = 0; i < constraintGroups.length; i++) {\n        group = constraintGroups[i];\n        for(axId in group) {\n            axOut = layoutOut[id2name(axId)];\n            if(axOut.fixedrange) {\n                for(var axId2 in group) {\n                    var axName2 = id2name(axId2);\n                    if((layoutIn[axName2] || {}).fixedrange === false) {\n                        Lib.warn(\n                            'fixedrange was specified as false for axis ' +\n                            axName2 + ' but was overridden because another ' +\n                            'axis in its constraint group has fixedrange true'\n                        );\n                    }\n                    layoutOut[axName2].fixedrange = true;\n                }\n                break;\n            }\n        }\n    }\n\n    // remove constraint groups that simply duplicate match groups\n    i = 0;\n    while(i < constraintGroups.length) {\n        group = constraintGroups[i];\n        for(axId in group) {\n            axOut = layoutOut[id2name(axId)];\n            if(axOut._matchGroup && Object.keys(axOut._matchGroup).length === Object.keys(group).length) {\n                constraintGroups.splice(i, 1);\n                i--;\n            }\n            break;\n        }\n        i++;\n    }\n\n    // save constraintGroup on each constrained axis\n    stash(constraintGroups, '_constraintGroup');\n\n    // make sure `matching` axes share values of necessary attributes\n    // Precedence (base axis is the one that doesn't list a `matches`, ie others\n    // all point to it):\n    // (1) explicitly defined value in the base axis\n    // (2) explicitly defined in another axis (arbitrary order)\n    // (3) default in the base axis\n    var matchAttrs = [\n        'constrain',\n        'range',\n        'autorange',\n        'rangemode',\n        'rangebreaks',\n        'categoryorder',\n        'categoryarray'\n    ];\n    var hasRange = false;\n    var hasDayOfWeekBreaks = false;\n\n    function setAttrVal() {\n        val = axOut[attr];\n        if(attr === 'rangebreaks') {\n            hasDayOfWeekBreaks = axOut._hasDayOfWeekBreaks;\n        }\n    }\n\n    for(i = 0; i < matchGroups.length; i++) {\n        group = matchGroups[i];\n\n        // find 'matching' range attrs\n        for(var j = 0; j < matchAttrs.length; j++) {\n            attr = matchAttrs[j];\n            val = null;\n            var baseAx;\n            for(axId in group) {\n                axName = id2name(axId);\n                axIn = layoutIn[axName];\n                axOut = layoutOut[axName];\n                if(!(attr in axOut)) {\n                    continue;\n                }\n                if(!axOut.matches) {\n                    baseAx = axOut;\n                    // top priority: explicit value in base axis\n                    if(attr in axIn) {\n                        setAttrVal();\n                        break;\n                    }\n                }\n                if(val === null && attr in axIn) {\n                    // second priority: first explicit value in another axis\n                    setAttrVal();\n                }\n            }\n\n            // special logic for coupling of range and autorange\n            // if nobody explicitly specifies autorange, but someone does\n            // explicitly specify range, autorange must be disabled.\n            if(attr === 'range' && val &&\n                axIn.range &&\n                axIn.range.length === 2 &&\n                axIn.range[0] !== null &&\n                axIn.range[1] !== null\n            ) {\n                hasRange = true;\n            }\n            if(attr === 'autorange' && val === null && hasRange) {\n                val = false;\n            }\n\n            if(val === null && attr in baseAx) {\n                // fallback: default value in base axis\n                val = baseAx[attr];\n            }\n            // but we still might not have a value, which is fine.\n            if(val !== null) {\n                for(axId in group) {\n                    axOut = layoutOut[id2name(axId)];\n                    axOut[attr] = attr === 'range' ? val.slice() : val;\n\n                    if(attr === 'rangebreaks') {\n                        axOut._hasDayOfWeekBreaks = hasDayOfWeekBreaks;\n                        setConvert(axOut, layoutOut);\n                    }\n                }\n            }\n        }\n    }\n};\n\nfunction handleOneAxDefaults(axIn, axOut, opts) {\n    var axIds = opts.axIds;\n    var layoutOut = opts.layoutOut;\n    var hasImage = opts.hasImage;\n    var constraintGroups = layoutOut._axisConstraintGroups;\n    var matchGroups = layoutOut._axisMatchGroups;\n    var axId = axOut._id;\n    var axLetter = axId.charAt(0);\n    var splomStash = ((layoutOut._splomAxes || {})[axLetter] || {})[axId] || {};\n    var thisID = axOut._id;\n    var isX = thisID.charAt(0) === 'x';\n\n    // Clear _matchGroup & _constraintGroup so relinkPrivateKeys doesn't keep\n    // an old one around. If this axis is in a group we'll set this again later\n    axOut._matchGroup = null;\n    axOut._constraintGroup = null;\n\n    function coerce(attr, dflt) {\n        return Lib.coerce(axIn, axOut, layoutAttributes, attr, dflt);\n    }\n\n    // coerce the constraint mechanics even if this axis has no scaleanchor\n    // because it may be the anchor of another axis.\n    coerce('constrain', hasImage ? 'domain' : 'range');\n    Lib.coerce(axIn, axOut, {\n        constraintoward: {\n            valType: 'enumerated',\n            values: isX ? ['left', 'center', 'right'] : ['bottom', 'middle', 'top'],\n            dflt: isX ? 'center' : 'middle'\n        }\n    }, 'constraintoward');\n\n    // If this axis is already part of a constraint group, we can't\n    // scaleanchor any other axis in that group, or we'd make a loop.\n    // Filter axIds to enforce this, also matching axis types.\n    var thisType = axOut.type;\n    var i, idi;\n\n    var linkableAxes = [];\n    for(i = 0; i < axIds.length; i++) {\n        idi = axIds[i];\n        if(idi === thisID) continue;\n\n        var axi = layoutOut[id2name(idi)];\n        if(axi.type === thisType) {\n            linkableAxes.push(idi);\n        }\n    }\n\n    var thisGroup = getConstraintGroup(constraintGroups, thisID);\n    if(thisGroup) {\n        var linkableAxesNoLoops = [];\n        for(i = 0; i < linkableAxes.length; i++) {\n            idi = linkableAxes[i];\n            if(!thisGroup[idi]) linkableAxesNoLoops.push(idi);\n        }\n        linkableAxes = linkableAxesNoLoops;\n    }\n\n    var canLink = linkableAxes.length;\n\n    var matches, scaleanchor;\n\n    if(canLink && (axIn.matches || splomStash.matches)) {\n        matches = Lib.coerce(axIn, axOut, {\n            matches: {\n                valType: 'enumerated',\n                values: linkableAxes,\n                dflt: linkableAxes.indexOf(splomStash.matches) !== -1 ? splomStash.matches : undefined\n            }\n        }, 'matches');\n    }\n\n    // 'matches' wins over 'scaleanchor' - each axis can only specify one\n    // constraint, but you can chain matches and scaleanchor constraints by\n    // specifying them in separate axes.\n    var scaleanchorDflt = hasImage && !isX ? axOut.anchor : undefined;\n    if(canLink && !matches && (axIn.scaleanchor || scaleanchorDflt)) {\n        scaleanchor = Lib.coerce(axIn, axOut, {\n            scaleanchor: {\n                valType: 'enumerated',\n                values: linkableAxes.concat([false])\n            }\n        }, 'scaleanchor', scaleanchorDflt);\n    }\n\n    if(matches) {\n        axOut._matchGroup = updateConstraintGroups(matchGroups, thisID, matches, 1);\n\n        // Also include match constraints in the scale groups\n        var matchedAx = layoutOut[id2name(matches)];\n        var matchRatio = extent(layoutOut, axOut) / extent(layoutOut, matchedAx);\n        if(isX !== (matches.charAt(0) === 'x')) {\n            // We don't yet know the actual scale ratio of x/y matches constraints,\n            // due to possible automargins, so just leave a placeholder for this:\n            // 'x' means \"x size over y size\", 'y' means the inverse.\n            // in principle in the constraint group you could get multiple of these.\n            matchRatio = (isX ? 'x' : 'y') + matchRatio;\n        }\n        updateConstraintGroups(constraintGroups, thisID, matches, matchRatio);\n    } else if(axIn.matches && axIds.indexOf(axIn.matches) !== -1) {\n        Lib.warn('ignored ' + axOut._name + '.matches: \"' +\n            axIn.matches + '\" to avoid an infinite loop');\n    }\n\n    if(scaleanchor) {\n        var scaleratio = coerce('scaleratio');\n\n        // TODO: I suppose I could do attribute.min: Number.MIN_VALUE to avoid zero,\n        // but that seems hacky. Better way to say \"must be a positive number\"?\n        // Of course if you use several super-tiny values you could eventually\n        // force a product of these to zero and all hell would break loose...\n        // Likewise with super-huge values.\n        if(!scaleratio) scaleratio = axOut.scaleratio = 1;\n\n        updateConstraintGroups(constraintGroups, thisID, scaleanchor, scaleratio);\n    } else if(axIn.scaleanchor && axIds.indexOf(axIn.scaleanchor) !== -1) {\n        Lib.warn('ignored ' + axOut._name + '.scaleanchor: \"' +\n            axIn.scaleanchor + '\" to avoid either an infinite loop ' +\n            'and possibly inconsistent scaleratios, or because this axis ' +\n            'declares a *matches* constraint.');\n    }\n}\n\nfunction extent(layoutOut, ax) {\n    var domain = ax.domain;\n    if(!domain) {\n        // at this point overlaying axes haven't yet inherited their main domains\n        // TODO: constrain: domain with overlaying axes is likely a bug.\n        domain = layoutOut[id2name(ax.overlaying)].domain;\n    }\n    return domain[1] - domain[0];\n}\n\nfunction getConstraintGroup(groups, thisID) {\n    for(var i = 0; i < groups.length; i++) {\n        if(groups[i][thisID]) {\n            return groups[i];\n        }\n    }\n    return null;\n}\n\n/*\n * Add this axis to the axis constraint groups, which is the collection\n * of axes that are all constrained together on scale (or matching).\n *\n * constraintGroups: a list of objects. each object is\n * {axis_id: scale_within_group}, where scale_within_group is\n * only important relative to the rest of the group, and defines\n * the relative scales between all axes in the group\n *\n * thisGroup: the group the current axis is already in\n * thisID: the id if the current axis\n * thatID: the id of the axis to scale it with\n * scaleratio: the ratio of this axis to the thatID axis\n */\nfunction updateConstraintGroups(constraintGroups, thisID, thatID, scaleratio) {\n    var i, j, groupi, keyj, thisGroupIndex;\n\n    var thisGroup = getConstraintGroup(constraintGroups, thisID);\n\n    if(thisGroup === null) {\n        thisGroup = {};\n        thisGroup[thisID] = 1;\n        thisGroupIndex = constraintGroups.length;\n        constraintGroups.push(thisGroup);\n    } else {\n        thisGroupIndex = constraintGroups.indexOf(thisGroup);\n    }\n\n    var thisGroupKeys = Object.keys(thisGroup);\n\n    // we know that this axis isn't in any other groups, but we don't know\n    // about the thatID axis. If it is, we need to merge the groups.\n    for(i = 0; i < constraintGroups.length; i++) {\n        groupi = constraintGroups[i];\n        if(i !== thisGroupIndex && groupi[thatID]) {\n            var baseScale = groupi[thatID];\n            for(j = 0; j < thisGroupKeys.length; j++) {\n                keyj = thisGroupKeys[j];\n                groupi[keyj] = multiplyScales(baseScale, multiplyScales(scaleratio, thisGroup[keyj]));\n            }\n            constraintGroups.splice(thisGroupIndex, 1);\n            return;\n        }\n    }\n\n    // otherwise, we insert the new thatID axis as the base scale (1)\n    // in its group, and scale the rest of the group to it\n    if(scaleratio !== 1) {\n        for(j = 0; j < thisGroupKeys.length; j++) {\n            var key = thisGroupKeys[j];\n            thisGroup[key] = multiplyScales(scaleratio, thisGroup[key]);\n        }\n    }\n    thisGroup[thatID] = 1;\n}\n\n// scales may be numbers or 'x1.3', 'yy4.5' etc to multiply by as-yet-unknown\n// ratios between x and y plot sizes n times\nfunction multiplyScales(a, b) {\n    var aPrefix = '';\n    var bPrefix = '';\n    var aLen, bLen;\n\n    if(typeof a === 'string') {\n        aPrefix = a.match(/^[xy]*/)[0];\n        aLen = aPrefix.length;\n        a = +a.substr(aLen);\n    }\n\n    if(typeof b === 'string') {\n        bPrefix = b.match(/^[xy]*/)[0];\n        bLen = bPrefix.length;\n        b = +b.substr(bLen);\n    }\n\n    var c = a * b;\n\n    // just two numbers\n    if(!aLen && !bLen) {\n        return c;\n    }\n\n    // one or more prefixes of the same type\n    if(!aLen || !bLen || aPrefix.charAt(0) === bPrefix.charAt(0)) {\n        return aPrefix + bPrefix + (a * b);\n    }\n\n    // x and y cancel each other out exactly - back to a number\n    if(aLen === bLen) {\n        return c;\n    }\n\n    // partial cancelation of prefixes\n    return (aLen > bLen ? aPrefix.substr(bLen) : bPrefix.substr(aLen)) + c;\n}\n\nfunction finalRatios(group, fullLayout) {\n    var size = fullLayout._size;\n    var yRatio = size.h / size.w;\n    var out = {};\n    var keys = Object.keys(group);\n    for(var i = 0; i < keys.length; i++) {\n        var key = keys[i];\n        var val = group[key];\n\n        if(typeof val === 'string') {\n            var prefix = val.match(/^[xy]*/)[0];\n            var pLen = prefix.length;\n            val = +val.substr(pLen);\n            var mult = prefix.charAt(0) === 'y' ? yRatio : (1 / yRatio);\n            for(var j = 0; j < pLen; j++) {\n                val *= mult;\n            }\n        }\n\n        out[key] = val;\n    }\n    return out;\n}\n\nexports.enforce = function enforce(gd) {\n    var fullLayout = gd._fullLayout;\n    var constraintGroups = fullLayout._axisConstraintGroups || [];\n\n    var i, j, group, axisID, ax, normScale, mode, factor;\n\n    // matching constraints are handled in the autorange code when autoranged,\n    // or in the supplyDefaults code when explicitly ranged.\n    // now we just need to handle scaleanchor constraints\n    // matches constraints that chain with scaleanchor constraints are included\n    // here too, but because matches has already been satisfied,\n    // any changes here should preserve that.\n    for(i = 0; i < constraintGroups.length; i++) {\n        group = finalRatios(constraintGroups[i], fullLayout);\n        var axisIDs = Object.keys(group);\n\n        var minScale = Infinity;\n        var maxScale = 0;\n        // mostly matchScale will be the same as minScale\n        // ie we expand axis ranges to encompass *everything*\n        // that's currently in any of their ranges, but during\n        // autorange of a subset of axes we will ignore other\n        // axes for this purpose.\n        var matchScale = Infinity;\n        var normScales = {};\n        var axes = {};\n        var hasAnyDomainConstraint = false;\n\n        // find the (normalized) scale of each axis in the group\n        for(j = 0; j < axisIDs.length; j++) {\n            axisID = axisIDs[j];\n            axes[axisID] = ax = fullLayout[id2name(axisID)];\n\n            if(ax._inputDomain) ax.domain = ax._inputDomain.slice();\n            else ax._inputDomain = ax.domain.slice();\n\n            if(!ax._inputRange) ax._inputRange = ax.range.slice();\n\n            // set axis scale here so we can use _m rather than\n            // having to calculate it from length and range\n            ax.setScale();\n\n            // abs: inverted scales still satisfy the constraint\n            normScales[axisID] = normScale = Math.abs(ax._m) / group[axisID];\n            minScale = Math.min(minScale, normScale);\n            if(ax.constrain === 'domain' || !ax._constraintShrinkable) {\n                matchScale = Math.min(matchScale, normScale);\n            }\n\n            // this has served its purpose, so remove it\n            delete ax._constraintShrinkable;\n            maxScale = Math.max(maxScale, normScale);\n\n            if(ax.constrain === 'domain') hasAnyDomainConstraint = true;\n        }\n\n        // Do we have a constraint mismatch? Give a small buffer for rounding errors\n        if(minScale > ALMOST_EQUAL * maxScale && !hasAnyDomainConstraint) continue;\n\n        // now increase any ranges we need to until all normalized scales are equal\n        for(j = 0; j < axisIDs.length; j++) {\n            axisID = axisIDs[j];\n            normScale = normScales[axisID];\n            ax = axes[axisID];\n            mode = ax.constrain;\n\n            // even if the scale didn't change, if we're shrinking domain\n            // we need to recalculate in case `constraintoward` changed\n            if(normScale !== matchScale || mode === 'domain') {\n                factor = normScale / matchScale;\n\n                if(mode === 'range') {\n                    scaleZoom(ax, factor);\n                } else {\n                    // mode === 'domain'\n\n                    var inputDomain = ax._inputDomain;\n                    var domainShrunk = (ax.domain[1] - ax.domain[0]) /\n                        (inputDomain[1] - inputDomain[0]);\n                    var rangeShrunk = (ax.r2l(ax.range[1]) - ax.r2l(ax.range[0])) /\n                        (ax.r2l(ax._inputRange[1]) - ax.r2l(ax._inputRange[0]));\n\n                    factor /= domainShrunk;\n\n                    if(factor * rangeShrunk < 1) {\n                        // we've asked to magnify the axis more than we can just by\n                        // enlarging the domain - so we need to constrict range\n                        ax.domain = ax._input.domain = inputDomain.slice();\n                        scaleZoom(ax, factor);\n                        continue;\n                    }\n\n                    if(rangeShrunk < 1) {\n                        // the range has previously been constricted by ^^, but we've\n                        // switched to the domain-constricted regime, so reset range\n                        ax.range = ax._input.range = ax._inputRange.slice();\n                        factor *= rangeShrunk;\n                    }\n\n                    if(ax.autorange) {\n                        /*\n                         * range & factor may need to change because range was\n                         * calculated for the larger scaling, so some pixel\n                         * paddings may get cut off when we reduce the domain.\n                         *\n                         * This is easier than the regular autorange calculation\n                         * because we already know the scaling `m`, but we still\n                         * need to cut out impossible constraints (like\n                         * annotations with super-long arrows). That's what\n                         * outerMin/Max are for - if the expansion was going to\n                         * go beyond the original domain, it must be impossible\n                         */\n                        var rl0 = ax.r2l(ax.range[0]);\n                        var rl1 = ax.r2l(ax.range[1]);\n                        var rangeCenter = (rl0 + rl1) / 2;\n                        var rangeMin = rangeCenter;\n                        var rangeMax = rangeCenter;\n                        var halfRange = Math.abs(rl1 - rangeCenter);\n                        // extra tiny bit for rounding errors, in case we actually\n                        // *are* expanding to the full domain\n                        var outerMin = rangeCenter - halfRange * factor * 1.0001;\n                        var outerMax = rangeCenter + halfRange * factor * 1.0001;\n                        var getPadMin = autorange.makePadFn(fullLayout, ax, 0);\n                        var getPadMax = autorange.makePadFn(fullLayout, ax, 1);\n\n                        updateDomain(ax, factor);\n                        var m = Math.abs(ax._m);\n                        var extremes = autorange.concatExtremes(gd, ax);\n                        var minArray = extremes.min;\n                        var maxArray = extremes.max;\n                        var newVal;\n                        var k;\n\n                        for(k = 0; k < minArray.length; k++) {\n                            newVal = minArray[k].val - getPadMin(minArray[k]) / m;\n                            if(newVal > outerMin && newVal < rangeMin) {\n                                rangeMin = newVal;\n                            }\n                        }\n\n                        for(k = 0; k < maxArray.length; k++) {\n                            newVal = maxArray[k].val + getPadMax(maxArray[k]) / m;\n                            if(newVal < outerMax && newVal > rangeMax) {\n                                rangeMax = newVal;\n                            }\n                        }\n\n                        var domainExpand = (rangeMax - rangeMin) / (2 * halfRange);\n                        factor /= domainExpand;\n\n                        rangeMin = ax.l2r(rangeMin);\n                        rangeMax = ax.l2r(rangeMax);\n                        ax.range = ax._input.range = (rl0 < rl1) ?\n                            [rangeMin, rangeMax] : [rangeMax, rangeMin];\n                    }\n\n                    updateDomain(ax, factor);\n                }\n            }\n        }\n    }\n};\n\nexports.getAxisGroup = function getAxisGroup(fullLayout, axId) {\n    var matchGroups = fullLayout._axisMatchGroups;\n\n    for(var i = 0; i < matchGroups.length; i++) {\n        var group = matchGroups[i];\n        if(group[axId]) return 'g' + i;\n    }\n    return axId;\n};\n\n// For use before autoranging, check if this axis was previously constrained\n// by domain but no longer is\nexports.clean = function clean(gd, ax) {\n    if(ax._inputDomain) {\n        var isConstrained = false;\n        var axId = ax._id;\n        var constraintGroups = gd._fullLayout._axisConstraintGroups;\n        for(var j = 0; j < constraintGroups.length; j++) {\n            if(constraintGroups[j][axId]) {\n                isConstrained = true;\n                break;\n            }\n        }\n        if(!isConstrained || ax.constrain !== 'domain') {\n            ax._input.domain = ax.domain = ax._inputDomain;\n            delete ax._inputDomain;\n        }\n    }\n};\n\nfunction updateDomain(ax, factor) {\n    var inputDomain = ax._inputDomain;\n    var centerFraction = FROM_BL[ax.constraintoward];\n    var center = inputDomain[0] + (inputDomain[1] - inputDomain[0]) * centerFraction;\n\n    ax.domain = ax._input.domain = [\n        center + (inputDomain[0] - center) / factor,\n        center + (inputDomain[1] - center) / factor\n    ];\n    ax.setScale();\n}\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar Lib = require('../../lib');\nvar numberFormat = Lib.numberFormat;\nvar tinycolor = require('tinycolor2');\nvar supportsPassive = require('has-passive-events');\n\nvar Registry = require('../../registry');\nvar strTranslate = Lib.strTranslate;\nvar svgTextUtils = require('../../lib/svg_text_utils');\nvar Color = require('../../components/color');\nvar Drawing = require('../../components/drawing');\nvar Fx = require('../../components/fx');\nvar Axes = require('./axes');\nvar setCursor = require('../../lib/setcursor');\nvar dragElement = require('../../components/dragelement');\nvar helpers = require('../../components/dragelement/helpers');\nvar selectingOrDrawing = helpers.selectingOrDrawing;\nvar freeMode = helpers.freeMode;\n\nvar FROM_TL = require('../../constants/alignment').FROM_TL;\nvar clearGlCanvases = require('../../lib/clear_gl_canvases');\nvar redrawReglTraces = require('../../plot_api/subroutines').redrawReglTraces;\n\nvar Plots = require('../plots');\n\nvar getFromId = require('./axis_ids').getFromId;\nvar prepSelect = require('../../components/selections').prepSelect;\nvar clearOutline = require('../../components/selections').clearOutline;\nvar selectOnClick = require('../../components/selections').selectOnClick;\nvar scaleZoom = require('./scale_zoom');\n\nvar constants = require('./constants');\nvar MINDRAG = constants.MINDRAG;\nvar MINZOOM = constants.MINZOOM;\n\n// flag for showing \"doubleclick to zoom out\" only at the beginning\nvar SHOWZOOMOUTTIP = true;\n\n// dragBox: create an element to drag one or more axis ends\n// inputs:\n//      plotinfo - which subplot are we making dragboxes on?\n//      x,y,w,h - left, top, width, height of the box\n//      ns - how does this drag the vertical axis?\n//          'n' - top only\n//          's' - bottom only\n//          'ns' - top and bottom together, difference unchanged\n//      ew - same for horizontal axis\nfunction makeDragBox(gd, plotinfo, x, y, w, h, ns, ew) {\n    // mouseDown stores ms of first mousedown event in the last\n    // `gd._context.doubleClickDelay` ms on the drag bars\n    // numClicks stores how many mousedowns have been seen\n    // within `gd._context.doubleClickDelay` so we can check for click or doubleclick events\n    // dragged stores whether a drag has occurred, so we don't have to\n    // redraw unnecessarily, ie if no move bigger than MINDRAG or MINZOOM px\n    var zoomlayer = gd._fullLayout._zoomlayer;\n    var isMainDrag = (ns + ew === 'nsew');\n    var singleEnd = (ns + ew).length === 1;\n\n    // main subplot x and y (i.e. found in plotinfo - the main ones)\n    var xa0, ya0;\n    // {ax._id: ax} hash objects\n    var xaHash, yaHash;\n    // xaHash/yaHash values (arrays)\n    var xaxes, yaxes;\n    // main axis offsets\n    var xs, ys;\n    // main axis lengths\n    var pw, ph;\n    // contains keys 'xaHash', 'yaHash', 'xaxes', and 'yaxes'\n    // which are the x/y {ax._id: ax} hash objects and their values\n    // for linked axis relative to this subplot\n    var links;\n    // similar to `links` but for matching axes\n    var matches;\n    // set to ew/ns val when active, set to '' when inactive\n    var xActive, yActive;\n    // are all axes in this subplot are fixed?\n    var allFixedRanges;\n    // do we need to edit x/y ranges?\n    var editX, editY;\n    // graph-wide optimization flags\n    var hasScatterGl, hasSplom, hasSVG;\n    // collected changes to be made to the plot by relayout at the end\n    var updates;\n    // scaling factors from css transform\n    var scaleX;\n    var scaleY;\n\n    // offset the x location of the box if needed\n    x += plotinfo.yaxis._shift;\n\n    function recomputeAxisLists() {\n        xa0 = plotinfo.xaxis;\n        ya0 = plotinfo.yaxis;\n        pw = xa0._length;\n        ph = ya0._length;\n        xs = xa0._offset;\n        ys = ya0._offset;\n\n        xaHash = {};\n        xaHash[xa0._id] = xa0;\n        yaHash = {};\n        yaHash[ya0._id] = ya0;\n\n        // if we're dragging two axes at once, also drag overlays\n        if(ns && ew) {\n            var overlays = plotinfo.overlays;\n            for(var i = 0; i < overlays.length; i++) {\n                var xa = overlays[i].xaxis;\n                xaHash[xa._id] = xa;\n                var ya = overlays[i].yaxis;\n                yaHash[ya._id] = ya;\n            }\n        }\n\n        xaxes = hashValues(xaHash);\n        yaxes = hashValues(yaHash);\n        xActive = isDirectionActive(xaxes, ew);\n        yActive = isDirectionActive(yaxes, ns);\n        allFixedRanges = !yActive && !xActive;\n\n        matches = calcLinks(gd, gd._fullLayout._axisMatchGroups, xaHash, yaHash);\n        links = calcLinks(gd, gd._fullLayout._axisConstraintGroups, xaHash, yaHash, matches);\n        var spConstrained = links.isSubplotConstrained || matches.isSubplotConstrained;\n        editX = ew || spConstrained;\n        editY = ns || spConstrained;\n\n        var fullLayout = gd._fullLayout;\n        hasScatterGl = fullLayout._has('scattergl');\n        hasSplom = fullLayout._has('splom');\n        hasSVG = fullLayout._has('svg');\n    }\n\n    recomputeAxisLists();\n\n    var cursor = getDragCursor(yActive + xActive, gd._fullLayout.dragmode, isMainDrag);\n    var dragger = makeRectDragger(plotinfo, ns + ew + 'drag', cursor, x, y, w, h);\n\n    // still need to make the element if the axes are disabled\n    // but nuke its events (except for maindrag which needs them for hover)\n    // and stop there\n    if(allFixedRanges && !isMainDrag) {\n        dragger.onmousedown = null;\n        dragger.style.pointerEvents = 'none';\n        return dragger;\n    }\n\n    var dragOptions = {\n        element: dragger,\n        gd: gd,\n        plotinfo: plotinfo\n    };\n\n    dragOptions.prepFn = function(e, startX, startY) {\n        var dragModePrev = dragOptions.dragmode;\n        var dragModeNow = gd._fullLayout.dragmode;\n        if(dragModeNow !== dragModePrev) {\n            dragOptions.dragmode = dragModeNow;\n        }\n\n        recomputeAxisLists();\n\n        scaleX = gd._fullLayout._invScaleX;\n        scaleY = gd._fullLayout._invScaleY;\n\n        if(!allFixedRanges) {\n            if(isMainDrag) {\n                // main dragger handles all drag modes, and changes\n                // to pan (or to zoom if it already is pan) on shift\n                if(e.shiftKey) {\n                    if(dragModeNow === 'pan') dragModeNow = 'zoom';\n                    else if(!selectingOrDrawing(dragModeNow)) dragModeNow = 'pan';\n                } else if(e.ctrlKey) {\n                    dragModeNow = 'pan';\n                }\n            } else {\n                // all other draggers just pan\n                dragModeNow = 'pan';\n            }\n        }\n\n        if(freeMode(dragModeNow)) dragOptions.minDrag = 1;\n        else dragOptions.minDrag = undefined;\n\n        if(selectingOrDrawing(dragModeNow)) {\n            dragOptions.xaxes = xaxes;\n            dragOptions.yaxes = yaxes;\n            // this attaches moveFn, clickFn, doneFn on dragOptions\n            prepSelect(e, startX, startY, dragOptions, dragModeNow);\n        } else {\n            dragOptions.clickFn = clickFn;\n            if(selectingOrDrawing(dragModePrev)) {\n                // TODO Fix potential bug\n                // Note: clearing / resetting selection state only happens, when user\n                // triggers at least one interaction in pan/zoom mode. Otherwise, the\n                // select/lasso outlines are deleted (in plots.js.cleanPlot) but the selection\n                // cache isn't cleared. So when the user switches back to select/lasso and\n                // 'adds to a selection' with Shift, the \"old\", seemingly removed outlines\n                // are redrawn again because the selection cache still holds their coordinates.\n                // However, this isn't easily solved, since plots.js would need\n                // to have a reference to the dragOptions object (which holds the\n                // selection cache).\n                clearAndResetSelect();\n            }\n\n            if(!allFixedRanges) {\n                if(dragModeNow === 'zoom') {\n                    dragOptions.moveFn = zoomMove;\n                    dragOptions.doneFn = zoomDone;\n\n                    // zoomMove takes care of the threshold, but we need to\n                    // minimize this so that constrained zoom boxes will flip\n                    // orientation at the right place\n                    dragOptions.minDrag = 1;\n\n                    zoomPrep(e, startX, startY);\n                } else if(dragModeNow === 'pan') {\n                    dragOptions.moveFn = plotDrag;\n                    dragOptions.doneFn = dragTail;\n                }\n            }\n        }\n\n        gd._fullLayout._redrag = function() {\n            var dragDataNow = gd._dragdata;\n\n            if(dragDataNow && dragDataNow.element === dragger) {\n                var dragModeNow = gd._fullLayout.dragmode;\n\n                if(!selectingOrDrawing(dragModeNow)) {\n                    recomputeAxisLists();\n                    updateSubplots([0, 0, pw, ph]);\n                    dragOptions.moveFn(dragDataNow.dx, dragDataNow.dy);\n                }\n            }\n        };\n    };\n\n    function clearAndResetSelect() {\n        // clear selection polygon cache (if any)\n        dragOptions.plotinfo.selection = false;\n        // clear selection outlines\n        clearOutline(gd);\n    }\n\n    function clickFn(numClicks, evt) {\n        var gd = dragOptions.gd;\n        if(gd._fullLayout._activeShapeIndex >= 0) {\n            gd._fullLayout._deactivateShape(gd);\n            return;\n        }\n\n        var clickmode = gd._fullLayout.clickmode;\n\n        removeZoombox(gd);\n\n        if(numClicks === 2 && !singleEnd) doubleClick();\n\n        if(isMainDrag) {\n            if(clickmode.indexOf('select') > -1) {\n                selectOnClick(evt, gd, xaxes, yaxes, plotinfo.id, dragOptions);\n            }\n\n            if(clickmode.indexOf('event') > -1) {\n                Fx.click(gd, evt, plotinfo.id);\n            }\n        } else if(numClicks === 1 && singleEnd) {\n            var ax = ns ? ya0 : xa0;\n            var end = (ns === 's' || ew === 'w') ? 0 : 1;\n            var attrStr = ax._name + '.range[' + end + ']';\n            var initialText = getEndText(ax, end);\n            var hAlign = 'left';\n            var vAlign = 'middle';\n\n            if(ax.fixedrange) return;\n\n            if(ns) {\n                vAlign = (ns === 'n') ? 'top' : 'bottom';\n                if(ax.side === 'right') hAlign = 'right';\n            } else if(ew === 'e') hAlign = 'right';\n\n            if(gd._context.showAxisRangeEntryBoxes) {\n                d3.select(dragger)\n                    .call(svgTextUtils.makeEditable, {\n                        gd: gd,\n                        immediate: true,\n                        background: gd._fullLayout.paper_bgcolor,\n                        text: String(initialText),\n                        fill: ax.tickfont ? ax.tickfont.color : '#444',\n                        horizontalAlign: hAlign,\n                        verticalAlign: vAlign\n                    })\n                    .on('edit', function(text) {\n                        var v = ax.d2r(text);\n                        if(v !== undefined) {\n                            Registry.call('_guiRelayout', gd, attrStr, v);\n                        }\n                    });\n            }\n        }\n    }\n\n    dragElement.init(dragOptions);\n\n    // x/y px position at start of drag\n    var x0, y0;\n    // bbox object of the zoombox\n    var box;\n    // luminance of bg behind zoombox\n    var lum;\n    // zoombox path outline\n    var path0;\n    // is zoombox dimmed (during drag)\n    var dimmed;\n    // 'x'-only, 'y' or 'xy' zooming\n    var zoomMode;\n    // zoombox d3 selection\n    var zb;\n    // zoombox corner d3 selection\n    var corners;\n    // zoom takes over minDrag, so it also has to take over gd._dragged\n    var zoomDragged;\n\n    function zoomPrep(e, startX, startY) {\n        var dragBBox = dragger.getBoundingClientRect();\n        x0 = startX - dragBBox.left;\n        y0 = startY - dragBBox.top;\n\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        box = {l: x0, r: x0, w: 0, t: y0, b: y0, h: 0};\n        lum = gd._hmpixcount ?\n            (gd._hmlumcount / gd._hmpixcount) :\n            tinycolor(gd._fullLayout.plot_bgcolor).getLuminance();\n        path0 = 'M0,0H' + pw + 'V' + ph + 'H0V0';\n        dimmed = false;\n        zoomMode = 'xy';\n        zoomDragged = false;\n        zb = makeZoombox(zoomlayer, lum, xs, ys, path0);\n        corners = makeCorners(zoomlayer, xs, ys);\n    }\n\n    function zoomMove(dx0, dy0) {\n        if(gd._transitioningWithDuration) {\n            return false;\n        }\n\n        var x1 = Math.max(0, Math.min(pw, scaleX * dx0 + x0));\n        var y1 = Math.max(0, Math.min(ph, scaleY * dy0 + y0));\n        var dx = Math.abs(x1 - x0);\n        var dy = Math.abs(y1 - y0);\n\n        box.l = Math.min(x0, x1);\n        box.r = Math.max(x0, x1);\n        box.t = Math.min(y0, y1);\n        box.b = Math.max(y0, y1);\n\n        function noZoom() {\n            zoomMode = '';\n            box.r = box.l;\n            box.t = box.b;\n            corners.attr('d', 'M0,0Z');\n        }\n\n        if(links.isSubplotConstrained) {\n            if(dx > MINZOOM || dy > MINZOOM) {\n                zoomMode = 'xy';\n                if(dx / pw > dy / ph) {\n                    dy = dx * ph / pw;\n                    if(y0 > y1) box.t = y0 - dy;\n                    else box.b = y0 + dy;\n                } else {\n                    dx = dy * pw / ph;\n                    if(x0 > x1) box.l = x0 - dx;\n                    else box.r = x0 + dx;\n                }\n                corners.attr('d', xyCorners(box));\n            } else {\n                noZoom();\n            }\n        } else if(matches.isSubplotConstrained) {\n            if(dx > MINZOOM || dy > MINZOOM) {\n                zoomMode = 'xy';\n\n                var r0 = Math.min(box.l / pw, (ph - box.b) / ph);\n                var r1 = Math.max(box.r / pw, (ph - box.t) / ph);\n\n                box.l = r0 * pw;\n                box.r = r1 * pw;\n                box.b = (1 - r0) * ph;\n                box.t = (1 - r1) * ph;\n                corners.attr('d', xyCorners(box));\n            } else {\n                noZoom();\n            }\n        } else if(!yActive || dy < Math.min(Math.max(dx * 0.6, MINDRAG), MINZOOM)) {\n            // look for small drags in one direction or the other,\n            // and only drag the other axis\n\n            if(dx < MINDRAG || !xActive) {\n                noZoom();\n            } else {\n                box.t = 0;\n                box.b = ph;\n                zoomMode = 'x';\n                corners.attr('d', xCorners(box, y0));\n            }\n        } else if(!xActive || dx < Math.min(dy * 0.6, MINZOOM)) {\n            box.l = 0;\n            box.r = pw;\n            zoomMode = 'y';\n            corners.attr('d', yCorners(box, x0));\n        } else {\n            zoomMode = 'xy';\n            corners.attr('d', xyCorners(box));\n        }\n        box.w = box.r - box.l;\n        box.h = box.b - box.t;\n\n        if(zoomMode) zoomDragged = true;\n        gd._dragged = zoomDragged;\n\n        updateZoombox(zb, corners, box, path0, dimmed, lum);\n        computeZoomUpdates();\n        gd.emit('plotly_relayouting', updates);\n        dimmed = true;\n    }\n\n    function computeZoomUpdates() {\n        updates = {};\n\n        // TODO: edit linked axes in zoomAxRanges and in dragTail\n        if(zoomMode === 'xy' || zoomMode === 'x') {\n            zoomAxRanges(xaxes, box.l / pw, box.r / pw, updates, links.xaxes);\n            updateMatchedAxRange('x', updates);\n        }\n        if(zoomMode === 'xy' || zoomMode === 'y') {\n            zoomAxRanges(yaxes, (ph - box.b) / ph, (ph - box.t) / ph, updates, links.yaxes);\n            updateMatchedAxRange('y', updates);\n        }\n    }\n\n    function zoomDone() {\n        computeZoomUpdates();\n        removeZoombox(gd);\n        dragTail();\n        showDoubleClickNotifier(gd);\n    }\n\n    // scroll zoom, on all draggers except corners\n    var scrollViewBox = [0, 0, pw, ph];\n    // wait a little after scrolling before redrawing\n    var redrawTimer = null;\n    var REDRAWDELAY = constants.REDRAWDELAY;\n    var mainplot = plotinfo.mainplot ? gd._fullLayout._plots[plotinfo.mainplot] : plotinfo;\n\n    function zoomWheel(e) {\n        // deactivate mousewheel scrolling on embedded graphs\n        // devs can override this with layout._enablescrollzoom,\n        // but _ ensures this setting won't leave their page\n        if(!gd._context._scrollZoom.cartesian && !gd._fullLayout._enablescrollzoom) {\n            return;\n        }\n\n        clearAndResetSelect();\n\n        // If a transition is in progress, then disable any behavior:\n        if(gd._transitioningWithDuration) {\n            e.preventDefault();\n            e.stopPropagation();\n            return;\n        }\n\n        recomputeAxisLists();\n\n        clearTimeout(redrawTimer);\n\n        var wheelDelta = -e.deltaY;\n        if(!isFinite(wheelDelta)) wheelDelta = e.wheelDelta / 10;\n        if(!isFinite(wheelDelta)) {\n            Lib.log('Did not find wheel motion attributes: ', e);\n            return;\n        }\n\n        var zoom = Math.exp(-Math.min(Math.max(wheelDelta, -20), 20) / 200);\n        var gbb = mainplot.draglayer.select('.nsewdrag').node().getBoundingClientRect();\n        var xfrac = (e.clientX - gbb.left) / gbb.width;\n        var yfrac = (gbb.bottom - e.clientY) / gbb.height;\n        var i;\n\n        function zoomWheelOneAxis(ax, centerFraction, zoom) {\n            if(ax.fixedrange) return;\n\n            var axRange = Lib.simpleMap(ax.range, ax.r2l);\n            var v0 = axRange[0] + (axRange[1] - axRange[0]) * centerFraction;\n            function doZoom(v) { return ax.l2r(v0 + (v - v0) * zoom); }\n            ax.range = axRange.map(doZoom);\n        }\n\n        if(editX) {\n            // if we're only zooming this axis because of constraints,\n            // zoom it about the center\n            if(!ew) xfrac = 0.5;\n\n            for(i = 0; i < xaxes.length; i++) {\n                zoomWheelOneAxis(xaxes[i], xfrac, zoom);\n            }\n            updateMatchedAxRange('x');\n\n            scrollViewBox[2] *= zoom;\n            scrollViewBox[0] += scrollViewBox[2] * xfrac * (1 / zoom - 1);\n        }\n        if(editY) {\n            if(!ns) yfrac = 0.5;\n\n            for(i = 0; i < yaxes.length; i++) {\n                zoomWheelOneAxis(yaxes[i], yfrac, zoom);\n            }\n            updateMatchedAxRange('y');\n\n            scrollViewBox[3] *= zoom;\n            scrollViewBox[1] += scrollViewBox[3] * (1 - yfrac) * (1 / zoom - 1);\n        }\n\n        // viewbox redraw at first\n        updateSubplots(scrollViewBox);\n        ticksAndAnnotations();\n\n        gd.emit('plotly_relayouting', updates);\n\n        // then replot after a delay to make sure\n        // no more scrolling is coming\n        redrawTimer = setTimeout(function() {\n            if(!gd._fullLayout) return;\n            scrollViewBox = [0, 0, pw, ph];\n            dragTail();\n        }, REDRAWDELAY);\n\n        e.preventDefault();\n        return;\n    }\n\n    // everything but the corners gets wheel zoom\n    if(ns.length * ew.length !== 1) {\n        attachWheelEventHandler(dragger, zoomWheel);\n    }\n\n    // plotDrag: move the plot in response to a drag\n    function plotDrag(dx, dy) {\n        dx = dx * scaleX;\n        dy = dy * scaleY;\n        // If a transition is in progress, then disable any behavior:\n        if(gd._transitioningWithDuration) {\n            return;\n        }\n\n        // prevent axis drawing from monkeying with margins until we're done\n        gd._fullLayout._replotting = true;\n\n        if(xActive === 'ew' || yActive === 'ns') {\n            var spDx = xActive ? -dx : 0;\n            var spDy = yActive ? -dy : 0;\n\n            if(matches.isSubplotConstrained) {\n                if(xActive && yActive) {\n                    var frac = (dx / pw - dy / ph) / 2;\n                    dx = frac * pw;\n                    dy = -frac * ph;\n                    spDx = -dx;\n                    spDy = -dy;\n                }\n                if(yActive) {\n                    spDx = -spDy * pw / ph;\n                } else {\n                    spDy = -spDx * ph / pw;\n                }\n            }\n            if(xActive) {\n                dragAxList(xaxes, dx);\n                updateMatchedAxRange('x');\n            }\n            if(yActive) {\n                dragAxList(yaxes, dy);\n                updateMatchedAxRange('y');\n            }\n            updateSubplots([spDx, spDy, pw, ph]);\n            ticksAndAnnotations();\n            gd.emit('plotly_relayouting', updates);\n            return;\n        }\n\n        // dz: set a new value for one end (0 or 1) of an axis array axArray,\n        // and return a pixel shift for that end for the viewbox\n        // based on pixel drag distance d\n        // TODO: this makes (generally non-fatal) errors when you get\n        // near floating point limits\n        function dz(axArray, end, d) {\n            var otherEnd = 1 - end;\n            var movedAx;\n            var newLinearizedEnd;\n            for(var i = 0; i < axArray.length; i++) {\n                var axi = axArray[i];\n                if(axi.fixedrange) continue;\n                movedAx = axi;\n                newLinearizedEnd = axi._rl[otherEnd] +\n                    (axi._rl[end] - axi._rl[otherEnd]) / dZoom(d / axi._length);\n                var newEnd = axi.l2r(newLinearizedEnd);\n\n                // if l2r comes back false or undefined, it means we've dragged off\n                // the end of valid ranges - so stop.\n                if(newEnd !== false && newEnd !== undefined) axi.range[end] = newEnd;\n            }\n            return movedAx._length * (movedAx._rl[end] - newLinearizedEnd) /\n                (movedAx._rl[end] - movedAx._rl[otherEnd]);\n        }\n\n        var dxySign = ((xActive === 'w') === (yActive === 'n')) ? 1 : -1;\n        if(xActive && yActive && (links.isSubplotConstrained || matches.isSubplotConstrained)) {\n            // dragging a corner of a constrained subplot:\n            // respect the fixed corner, but harmonize dx and dy\n            var dxyFraction = (dx / pw + dxySign * dy / ph) / 2;\n            dx = dxyFraction * pw;\n            dy = dxySign * dxyFraction * ph;\n        }\n\n        var xStart, yStart;\n\n        if(xActive === 'w') dx = dz(xaxes, 0, dx);\n        else if(xActive === 'e') dx = dz(xaxes, 1, -dx);\n        else if(!xActive) dx = 0;\n\n        if(yActive === 'n') dy = dz(yaxes, 1, dy);\n        else if(yActive === 's') dy = dz(yaxes, 0, -dy);\n        else if(!yActive) dy = 0;\n\n        xStart = (xActive === 'w') ? dx : 0;\n        yStart = (yActive === 'n') ? dy : 0;\n\n        if(\n            (links.isSubplotConstrained && !matches.isSubplotConstrained) ||\n            // NW or SE on matching axes - create a symmetric zoom\n            (matches.isSubplotConstrained && xActive && yActive && dxySign > 0)\n        ) {\n            var i;\n            if(matches.isSubplotConstrained || (!xActive && yActive.length === 1)) {\n                // dragging one end of the y axis of a constrained subplot\n                // scale the other axis the same about its middle\n                for(i = 0; i < xaxes.length; i++) {\n                    xaxes[i].range = xaxes[i]._r.slice();\n                    scaleZoom(xaxes[i], 1 - dy / ph);\n                }\n                dx = dy * pw / ph;\n                xStart = dx / 2;\n            }\n            if(matches.isSubplotConstrained || (!yActive && xActive.length === 1)) {\n                for(i = 0; i < yaxes.length; i++) {\n                    yaxes[i].range = yaxes[i]._r.slice();\n                    scaleZoom(yaxes[i], 1 - dx / pw);\n                }\n                dy = dx * ph / pw;\n                yStart = dy / 2;\n            }\n        }\n\n        if(!matches.isSubplotConstrained || !yActive) {\n            updateMatchedAxRange('x');\n        }\n        if(!matches.isSubplotConstrained || !xActive) {\n            updateMatchedAxRange('y');\n        }\n        var xSize = pw - dx;\n        var ySize = ph - dy;\n        if(matches.isSubplotConstrained && !(xActive && yActive)) {\n            if(xActive) {\n                yStart = xStart ? 0 : (dx * ph / pw);\n                ySize = xSize * ph / pw;\n            } else {\n                xStart = yStart ? 0 : (dy * pw / ph);\n                xSize = ySize * pw / ph;\n            }\n        }\n        updateSubplots([xStart, yStart, xSize, ySize]);\n        ticksAndAnnotations();\n        gd.emit('plotly_relayouting', updates);\n    }\n\n    function updateMatchedAxRange(axLetter, out) {\n        var matchedAxes = matches.isSubplotConstrained ?\n            {x: yaxes, y: xaxes}[axLetter] :\n            matches[axLetter + 'axes'];\n\n        var constrainedAxes = matches.isSubplotConstrained ?\n            {x: xaxes, y: yaxes}[axLetter] :\n            [];\n\n        for(var i = 0; i < matchedAxes.length; i++) {\n            var ax = matchedAxes[i];\n            var axId = ax._id;\n            var axId2 = matches.xLinks[axId] || matches.yLinks[axId];\n            var ax2 = constrainedAxes[0] || xaHash[axId2] || yaHash[axId2];\n\n            if(ax2) {\n                if(out) {\n                    // zoombox case - don't mutate 'range', just add keys in 'updates'\n                    out[ax._name + '.range[0]'] = out[ax2._name + '.range[0]'];\n                    out[ax._name + '.range[1]'] = out[ax2._name + '.range[1]'];\n                } else {\n                    ax.range = ax2.range.slice();\n                }\n            }\n        }\n    }\n\n    // Draw ticks and annotations (and other components) when ranges change.\n    // Also records the ranges that have changed for use by update at the end.\n    function ticksAndAnnotations() {\n        var activeAxIds = [];\n        var i;\n\n        function pushActiveAxIds(axList) {\n            for(i = 0; i < axList.length; i++) {\n                if(!axList[i].fixedrange) activeAxIds.push(axList[i]._id);\n            }\n        }\n\n        function pushActiveAxIdsSynced(axList, axisType) {\n            for(i = 0; i < axList.length; i++) {\n                var axListI = axList[i];\n                var axListIType = axListI[axisType];\n                if(!axListI.fixedrange && axListIType.tickmode === 'sync') activeAxIds.push(axListIType._id);\n            }\n        }\n\n        if(editX) {\n            pushActiveAxIds(xaxes);\n            pushActiveAxIds(links.xaxes);\n            pushActiveAxIds(matches.xaxes);\n            pushActiveAxIdsSynced(plotinfo.overlays, 'xaxis');\n        }\n        if(editY) {\n            pushActiveAxIds(yaxes);\n            pushActiveAxIds(links.yaxes);\n            pushActiveAxIds(matches.yaxes);\n            pushActiveAxIdsSynced(plotinfo.overlays, 'yaxis');\n        }\n\n        updates = {};\n        for(i = 0; i < activeAxIds.length; i++) {\n            var axId = activeAxIds[i];\n            var ax = getFromId(gd, axId);\n            Axes.drawOne(gd, ax, {skipTitle: true});\n            updates[ax._name + '.range[0]'] = ax.range[0];\n            updates[ax._name + '.range[1]'] = ax.range[1];\n        }\n\n        Axes.redrawComponents(gd, activeAxIds);\n    }\n\n    function doubleClick() {\n        if(gd._transitioningWithDuration) return;\n\n        var doubleClickConfig = gd._context.doubleClick;\n\n        var axList = [];\n        if(xActive) axList = axList.concat(xaxes);\n        if(yActive) axList = axList.concat(yaxes);\n        if(matches.xaxes) axList = axList.concat(matches.xaxes);\n        if(matches.yaxes) axList = axList.concat(matches.yaxes);\n\n        var attrs = {};\n        var ax, i;\n\n        // For reset+autosize mode:\n        // If *any* of the main axes is not at its initial range\n        // (or autoranged, if we have no initial range, to match the logic in\n        // doubleClickConfig === 'reset' below), we reset.\n        // If they are *all* at their initial ranges, then we autosize.\n        if(doubleClickConfig === 'reset+autosize') {\n            doubleClickConfig = 'autosize';\n\n            for(i = 0; i < axList.length; i++) {\n                ax = axList[i];\n                var r0 = ax._rangeInitial0;\n                var r1 = ax._rangeInitial1;\n                var hasRangeInitial =\n                    r0 !== undefined ||\n                    r1 !== undefined;\n\n                if((hasRangeInitial && (\n                        (r0 !== undefined && r0 !== ax.range[0]) ||\n                        (r1 !== undefined && r1 !== ax.range[1])\n                    )) ||\n                    (!hasRangeInitial && ax.autorange !== true)\n                ) {\n                    doubleClickConfig = 'reset';\n                    break;\n                }\n            }\n        }\n\n        if(doubleClickConfig === 'autosize') {\n            // don't set the linked axes here, so relayout marks them as shrinkable\n            // and we autosize just to the requested axis/axes\n            for(i = 0; i < axList.length; i++) {\n                ax = axList[i];\n                if(!ax.fixedrange) attrs[ax._name + '.autorange'] = true;\n            }\n        } else if(doubleClickConfig === 'reset') {\n            // when we're resetting, reset all linked axes too, so we get back\n            // to the fully-auto-with-constraints situation\n            if(xActive || links.isSubplotConstrained) axList = axList.concat(links.xaxes);\n            if(yActive && !links.isSubplotConstrained) axList = axList.concat(links.yaxes);\n\n            if(links.isSubplotConstrained) {\n                if(!xActive) axList = axList.concat(xaxes);\n                else if(!yActive) axList = axList.concat(yaxes);\n            }\n\n            for(i = 0; i < axList.length; i++) {\n                ax = axList[i];\n\n                if(!ax.fixedrange) {\n                    var axName = ax._name;\n\n                    var autorangeInitial = ax._autorangeInitial;\n                    if(ax._rangeInitial0 === undefined && ax._rangeInitial1 === undefined) {\n                        attrs[axName + '.autorange'] = true;\n                    } else if(ax._rangeInitial0 === undefined) {\n                        attrs[axName + '.autorange'] = autorangeInitial;\n                        attrs[axName + '.range'] = [null, ax._rangeInitial1];\n                    } else if(ax._rangeInitial1 === undefined) {\n                        attrs[axName + '.range'] = [ax._rangeInitial0, null];\n                        attrs[axName + '.autorange'] = autorangeInitial;\n                    } else {\n                        attrs[axName + '.range'] = [ax._rangeInitial0, ax._rangeInitial1];\n                    }\n                }\n            }\n        }\n\n        gd.emit('plotly_doubleclick', null);\n        Registry.call('_guiRelayout', gd, attrs);\n    }\n\n    // dragTail - finish a drag event with a redraw\n    function dragTail() {\n        // put the subplot viewboxes back to default (Because we're going to)\n        // be repositioning the data in the relayout. But DON'T call\n        // ticksAndAnnotations again - it's unnecessary and would overwrite `updates`\n        updateSubplots([0, 0, pw, ph]);\n\n        // since we may have been redrawing some things during the drag, we may have\n        // accumulated MathJax promises - wait for them before we relayout.\n        Lib.syncOrAsync([\n            Plots.previousPromises,\n            function() {\n                gd._fullLayout._replotting = false;\n                Registry.call('_guiRelayout', gd, updates);\n            }\n        ], gd);\n    }\n\n    // updateSubplots - find all plot viewboxes that should be\n    // affected by this drag, and update them. look for all plots\n    // sharing an affected axis (including the one being dragged),\n    // includes also scattergl and splom logic.\n    function updateSubplots(viewBox) {\n        var fullLayout = gd._fullLayout;\n        var plotinfos = fullLayout._plots;\n        var subplots = fullLayout._subplots.cartesian;\n        var i, sp, xa, ya;\n\n        if(hasSplom) {\n            Registry.subplotsRegistry.splom.drag(gd);\n        }\n\n        if(hasScatterGl) {\n            for(i = 0; i < subplots.length; i++) {\n                sp = plotinfos[subplots[i]];\n                xa = sp.xaxis;\n                ya = sp.yaxis;\n\n                if(sp._scene) {\n                    var xrng = Lib.simpleMap(xa.range, xa.r2l);\n                    var yrng = Lib.simpleMap(ya.range, ya.r2l);\n\n                    if(xa.limitRange) xa.limitRange();\n                    if(ya.limitRange) ya.limitRange();\n\n                    xrng = xa.range;\n                    yrng = ya.range;\n\n                    sp._scene.update({range: [xrng[0], yrng[0], xrng[1], yrng[1]]});\n                }\n            }\n        }\n\n        if(hasSplom || hasScatterGl) {\n            clearGlCanvases(gd);\n            redrawReglTraces(gd);\n        }\n\n        if(hasSVG) {\n            var xScaleFactor = viewBox[2] / xa0._length;\n            var yScaleFactor = viewBox[3] / ya0._length;\n\n            for(i = 0; i < subplots.length; i++) {\n                sp = plotinfos[subplots[i]];\n                xa = sp.xaxis;\n                ya = sp.yaxis;\n\n                var editX2 = (editX || matches.isSubplotConstrained) && !xa.fixedrange && xaHash[xa._id];\n                var editY2 = (editY || matches.isSubplotConstrained) && !ya.fixedrange && yaHash[ya._id];\n\n                var xScaleFactor2, yScaleFactor2;\n                var clipDx, clipDy;\n\n                if(editX2) {\n                    xScaleFactor2 = xScaleFactor;\n                    clipDx = ew || matches.isSubplotConstrained ? viewBox[0] : getShift(xa, xScaleFactor2);\n                } else if(matches.xaHash[xa._id]) {\n                    xScaleFactor2 = xScaleFactor;\n                    clipDx = viewBox[0] * xa._length / xa0._length;\n                } else if(matches.yaHash[xa._id]) {\n                    xScaleFactor2 = yScaleFactor;\n                    clipDx = yActive === 'ns' ?\n                        -viewBox[1] * xa._length / ya0._length :\n                        getShift(xa, xScaleFactor2, {n: 'top', s: 'bottom'}[yActive]);\n                } else {\n                    xScaleFactor2 = getLinkedScaleFactor(xa, xScaleFactor, yScaleFactor);\n                    clipDx = scaleAndGetShift(xa, xScaleFactor2);\n                }\n\n                if(xScaleFactor2 > 1 && (\n                    (xa.maxallowed !== undefined && editX === (xa.range[0] < xa.range[1] ? 'e' : 'w')) ||\n                    (xa.minallowed !== undefined && editX === (xa.range[0] < xa.range[1] ? 'w' : 'e'))\n                )) {\n                    xScaleFactor2 = 1;\n                    clipDx = 0;\n                }\n\n                if(editY2) {\n                    yScaleFactor2 = yScaleFactor;\n                    clipDy = ns || matches.isSubplotConstrained ? viewBox[1] : getShift(ya, yScaleFactor2);\n                } else if(matches.yaHash[ya._id]) {\n                    yScaleFactor2 = yScaleFactor;\n                    clipDy = viewBox[1] * ya._length / ya0._length;\n                } else if(matches.xaHash[ya._id]) {\n                    yScaleFactor2 = xScaleFactor;\n                    clipDy = xActive === 'ew' ?\n                        -viewBox[0] * ya._length / xa0._length :\n                        getShift(ya, yScaleFactor2, {e: 'right', w: 'left'}[xActive]);\n                } else {\n                    yScaleFactor2 = getLinkedScaleFactor(ya, xScaleFactor, yScaleFactor);\n                    clipDy = scaleAndGetShift(ya, yScaleFactor2);\n                }\n\n                if(yScaleFactor2 > 1 && (\n                    (ya.maxallowed !== undefined && editY === (ya.range[0] < ya.range[1] ? 'n' : 's')) ||\n                    (ya.minallowed !== undefined && editY === (ya.range[0] < ya.range[1] ? 's' : 'n'))\n                )) {\n                    yScaleFactor2 = 1;\n                    clipDy = 0;\n                }\n\n                // don't scale at all if neither axis is scalable here\n                if(!xScaleFactor2 && !yScaleFactor2) {\n                    continue;\n                }\n\n                // but if only one is, reset the other axis scaling\n                if(!xScaleFactor2) xScaleFactor2 = 1;\n                if(!yScaleFactor2) yScaleFactor2 = 1;\n\n                var plotDx = xa._offset - clipDx / xScaleFactor2;\n                var plotDy = ya._offset - clipDy / yScaleFactor2;\n\n                // TODO could be more efficient here:\n                // setTranslate and setScale do a lot of extra work\n                // when working independently, should perhaps combine\n                // them into a single routine.\n                sp.clipRect\n                    .call(Drawing.setTranslate, clipDx, clipDy)\n                    .call(Drawing.setScale, xScaleFactor2, yScaleFactor2);\n\n                sp.plot\n                    .call(Drawing.setTranslate, plotDx, plotDy)\n                    .call(Drawing.setScale, 1 / xScaleFactor2, 1 / yScaleFactor2);\n\n                // apply an inverse scale to individual points to counteract\n                // the scale of the trace group.\n                // apply only when scale changes, as adjusting the scale of\n                // all the points can be expansive.\n                if(xScaleFactor2 !== sp.xScaleFactor || yScaleFactor2 !== sp.yScaleFactor) {\n                    Drawing.setPointGroupScale(sp.zoomScalePts, xScaleFactor2, yScaleFactor2);\n                    Drawing.setTextPointsScale(sp.zoomScaleTxt, xScaleFactor2, yScaleFactor2);\n                }\n\n                Drawing.hideOutsideRangePoints(sp.clipOnAxisFalseTraces, sp);\n\n                // update x/y scaleFactor stash\n                sp.xScaleFactor = xScaleFactor2;\n                sp.yScaleFactor = yScaleFactor2;\n            }\n        }\n    }\n\n    // Find the appropriate scaling for this axis, if it's linked to the\n    // dragged axes by constraints. 0 is special, it means this axis shouldn't\n    // ever be scaled (will be converted to 1 if the other axis is scaled)\n    function getLinkedScaleFactor(ax, xScaleFactor, yScaleFactor) {\n        if(ax.fixedrange) return 0;\n\n        if(editX && links.xaHash[ax._id]) {\n            return xScaleFactor;\n        }\n        if(editY && (links.isSubplotConstrained ? links.xaHash : links.yaHash)[ax._id]) {\n            return yScaleFactor;\n        }\n        return 0;\n    }\n\n    function scaleAndGetShift(ax, scaleFactor) {\n        if(scaleFactor) {\n            ax.range = ax._r.slice();\n            scaleZoom(ax, scaleFactor);\n            return getShift(ax, scaleFactor);\n        }\n        return 0;\n    }\n\n    function getShift(ax, scaleFactor, from) {\n        return ax._length * (1 - scaleFactor) * FROM_TL[from || ax.constraintoward || 'middle'];\n    }\n\n    return dragger;\n}\n\nfunction makeDragger(plotinfo, nodeName, dragClass, cursor) {\n    var dragger3 = Lib.ensureSingle(plotinfo.draglayer, nodeName, dragClass, function(s) {\n        s.classed('drag', true)\n            .style({fill: 'transparent', 'stroke-width': 0})\n            .attr('data-subplot', plotinfo.id);\n    });\n\n    dragger3.call(setCursor, cursor);\n\n    return dragger3.node();\n}\n\nfunction makeRectDragger(plotinfo, dragClass, cursor, x, y, w, h) {\n    var dragger = makeDragger(plotinfo, 'rect', dragClass, cursor);\n    d3.select(dragger).call(Drawing.setRect, x, y, w, h);\n    return dragger;\n}\n\nfunction isDirectionActive(axList, activeVal) {\n    for(var i = 0; i < axList.length; i++) {\n        if(!axList[i].fixedrange) return activeVal;\n    }\n    return '';\n}\n\nfunction getEndText(ax, end) {\n    var initialVal = ax.range[end];\n    var diff = Math.abs(initialVal - ax.range[1 - end]);\n    var dig;\n\n    // TODO: this should basically be ax.r2d but we're doing extra\n    // rounding here... can we clean up at all?\n    if(ax.type === 'date') {\n        return initialVal;\n    } else if(ax.type === 'log') {\n        dig = Math.ceil(Math.max(0, -Math.log(diff) / Math.LN10)) + 3;\n        return numberFormat('.' + dig + 'g')(Math.pow(10, initialVal));\n    } else { // linear numeric (or category... but just show numbers here)\n        dig = Math.floor(Math.log(Math.abs(initialVal)) / Math.LN10) -\n            Math.floor(Math.log(diff) / Math.LN10) + 4;\n        return numberFormat('.' + String(dig) + 'g')(initialVal);\n    }\n}\n\nfunction zoomAxRanges(axList, r0Fraction, r1Fraction, updates, linkedAxes) {\n    for(var i = 0; i < axList.length; i++) {\n        var axi = axList[i];\n        if(axi.fixedrange) continue;\n\n        if(axi.rangebreaks) {\n            var isY = axi._id.charAt(0) === 'y';\n            var r0F = isY ? (1 - r0Fraction) : r0Fraction;\n            var r1F = isY ? (1 - r1Fraction) : r1Fraction;\n\n            updates[axi._name + '.range[0]'] = axi.l2r(axi.p2l(r0F * axi._length));\n            updates[axi._name + '.range[1]'] = axi.l2r(axi.p2l(r1F * axi._length));\n        } else {\n            var axRangeLinear0 = axi._rl[0];\n            var axRangeLinearSpan = axi._rl[1] - axRangeLinear0;\n            updates[axi._name + '.range[0]'] = axi.l2r(axRangeLinear0 + axRangeLinearSpan * r0Fraction);\n            updates[axi._name + '.range[1]'] = axi.l2r(axRangeLinear0 + axRangeLinearSpan * r1Fraction);\n        }\n    }\n\n    // zoom linked axes about their centers\n    if(linkedAxes && linkedAxes.length) {\n        var linkedR0Fraction = (r0Fraction + (1 - r1Fraction)) / 2;\n        zoomAxRanges(linkedAxes, linkedR0Fraction, 1 - linkedR0Fraction, updates, []);\n    }\n}\n\nfunction dragAxList(axList, pix) {\n    for(var i = 0; i < axList.length; i++) {\n        var axi = axList[i];\n        if(!axi.fixedrange) {\n            if(axi.rangebreaks) {\n                var p0 = 0;\n                var p1 = axi._length;\n                var d0 = axi.p2l(p0 + pix) - axi.p2l(p0);\n                var d1 = axi.p2l(p1 + pix) - axi.p2l(p1);\n                var delta = (d0 + d1) / 2;\n\n                axi.range = [\n                    axi.l2r(axi._rl[0] - delta),\n                    axi.l2r(axi._rl[1] - delta)\n                ];\n            } else {\n                axi.range = [\n                    axi.l2r(axi._rl[0] - pix / axi._m),\n                    axi.l2r(axi._rl[1] - pix / axi._m)\n                ];\n            }\n\n            if(axi.limitRange) axi.limitRange();\n        }\n    }\n}\n\n// common transform for dragging one end of an axis\n// d>0 is compressing scale (cursor is over the plot,\n//  the axis end should move with the cursor)\n// d<0 is expanding (cursor is off the plot, axis end moves\n//  nonlinearly so you can expand far)\nfunction dZoom(d) {\n    return 1 - ((d >= 0) ? Math.min(d, 0.9) :\n        1 / (1 / Math.max(d, -0.3) + 3.222));\n}\n\nfunction getDragCursor(nsew, dragmode, isMainDrag) {\n    if(!nsew) return 'pointer';\n    if(nsew === 'nsew') {\n        // in this case here, clear cursor and\n        // use the cursor style set on <g .draglayer>\n        if(isMainDrag) return '';\n        if(dragmode === 'pan') return 'move';\n        return 'crosshair';\n    }\n    return nsew.toLowerCase() + '-resize';\n}\n\nfunction makeZoombox(zoomlayer, lum, xs, ys, path0) {\n    return zoomlayer.append('path')\n        .attr('class', 'zoombox')\n        .style({\n            fill: lum > 0.2 ? 'rgba(0,0,0,0)' : 'rgba(255,255,255,0)',\n            'stroke-width': 0\n        })\n        .attr('transform', strTranslate(xs, ys))\n        .attr('d', path0 + 'Z');\n}\n\nfunction makeCorners(zoomlayer, xs, ys) {\n    return zoomlayer.append('path')\n        .attr('class', 'zoombox-corners')\n        .style({\n            fill: Color.background,\n            stroke: Color.defaultLine,\n            'stroke-width': 1,\n            opacity: 0\n        })\n        .attr('transform', strTranslate(xs, ys))\n        .attr('d', 'M0,0Z');\n}\n\nfunction updateZoombox(zb, corners, box, path0, dimmed, lum) {\n    zb.attr('d',\n        path0 + 'M' + (box.l) + ',' + (box.t) + 'v' + (box.h) +\n        'h' + (box.w) + 'v-' + (box.h) + 'h-' + (box.w) + 'Z');\n    transitionZoombox(zb, corners, dimmed, lum);\n}\n\nfunction transitionZoombox(zb, corners, dimmed, lum) {\n    if(!dimmed) {\n        zb.transition()\n            .style('fill', lum > 0.2 ? 'rgba(0,0,0,0.4)' :\n                'rgba(255,255,255,0.3)')\n            .duration(200);\n        corners.transition()\n            .style('opacity', 1)\n            .duration(200);\n    }\n}\n\nfunction removeZoombox(gd) {\n    d3.select(gd)\n        .selectAll('.zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners')\n        .remove();\n}\n\nfunction showDoubleClickNotifier(gd) {\n    if(SHOWZOOMOUTTIP && gd.data && gd._context.showTips) {\n        Lib.notifier(Lib._(gd, 'Double-click to zoom back out'), 'long');\n        SHOWZOOMOUTTIP = false;\n    }\n}\n\nfunction xCorners(box, y0) {\n    return 'M' +\n        (box.l - 0.5) + ',' + (y0 - MINZOOM - 0.5) +\n        'h-3v' + (2 * MINZOOM + 1) + 'h3ZM' +\n        (box.r + 0.5) + ',' + (y0 - MINZOOM - 0.5) +\n        'h3v' + (2 * MINZOOM + 1) + 'h-3Z';\n}\n\nfunction yCorners(box, x0) {\n    return 'M' +\n        (x0 - MINZOOM - 0.5) + ',' + (box.t - 0.5) +\n        'v-3h' + (2 * MINZOOM + 1) + 'v3ZM' +\n        (x0 - MINZOOM - 0.5) + ',' + (box.b + 0.5) +\n        'v3h' + (2 * MINZOOM + 1) + 'v-3Z';\n}\n\nfunction xyCorners(box) {\n    var clen = Math.floor(Math.min(box.b - box.t, box.r - box.l, MINZOOM) / 2);\n    return 'M' +\n        (box.l - 3.5) + ',' + (box.t - 0.5 + clen) + 'h3v' + (-clen) +\n            'h' + clen + 'v-3h-' + (clen + 3) + 'ZM' +\n        (box.r + 3.5) + ',' + (box.t - 0.5 + clen) + 'h-3v' + (-clen) +\n            'h' + (-clen) + 'v-3h' + (clen + 3) + 'ZM' +\n        (box.r + 3.5) + ',' + (box.b + 0.5 - clen) + 'h-3v' + clen +\n            'h' + (-clen) + 'v3h' + (clen + 3) + 'ZM' +\n        (box.l - 3.5) + ',' + (box.b + 0.5 - clen) + 'h3v' + clen +\n            'h' + clen + 'v3h-' + (clen + 3) + 'Z';\n}\n\nfunction calcLinks(gd, groups, xaHash, yaHash, exclude) {\n    var isSubplotConstrained = false;\n    var xLinks = {};\n    var yLinks = {};\n    var xID, yID, xLinkID, yLinkID;\n    var xExclude = (exclude || {}).xaHash;\n    var yExclude = (exclude || {}).yaHash;\n\n    for(var i = 0; i < groups.length; i++) {\n        var group = groups[i];\n        // check if any of the x axes we're dragging is in this constraint group\n        for(xID in xaHash) {\n            if(group[xID]) {\n                // put the rest of these axes into xLinks, if we're not already\n                // dragging them, so we know to scale these axes automatically too\n                // to match the changes in the dragged x axes\n                for(xLinkID in group) {\n                    if(\n                        !(exclude && (xExclude[xLinkID] || yExclude[xLinkID])) &&\n                        !(xLinkID.charAt(0) === 'x' ? xaHash : yaHash)[xLinkID]\n                    ) {\n                        xLinks[xLinkID] = xID;\n                    }\n                }\n\n                // check if the x and y axes of THIS drag are linked\n                for(yID in yaHash) {\n                    if(\n                        !(exclude && (xExclude[yID] || yExclude[yID])) &&\n                        group[yID]\n                    ) {\n                        isSubplotConstrained = true;\n                    }\n                }\n            }\n        }\n\n        // now check if any of the y axes we're dragging is in this constraint group\n        // only look for outside links, as we've already checked for links within the dragger\n        for(yID in yaHash) {\n            if(group[yID]) {\n                for(yLinkID in group) {\n                    if(\n                        !(exclude && (xExclude[yLinkID] || yExclude[yLinkID])) &&\n                        !(yLinkID.charAt(0) === 'x' ? xaHash : yaHash)[yLinkID]\n                    ) {\n                        yLinks[yLinkID] = yID;\n                    }\n                }\n            }\n        }\n    }\n\n    if(isSubplotConstrained) {\n        // merge xLinks and yLinks if the subplot is constrained,\n        // since we'll always apply both anyway and the two will contain\n        // duplicates\n        Lib.extendFlat(xLinks, yLinks);\n        yLinks = {};\n    }\n\n    var xaHashLinked = {};\n    var xaxesLinked = [];\n    for(xLinkID in xLinks) {\n        var xa = getFromId(gd, xLinkID);\n        xaxesLinked.push(xa);\n        xaHashLinked[xa._id] = xa;\n    }\n\n    var yaHashLinked = {};\n    var yaxesLinked = [];\n    for(yLinkID in yLinks) {\n        var ya = getFromId(gd, yLinkID);\n        yaxesLinked.push(ya);\n        yaHashLinked[ya._id] = ya;\n    }\n\n    return {\n        xaHash: xaHashLinked,\n        yaHash: yaHashLinked,\n        xaxes: xaxesLinked,\n        yaxes: yaxesLinked,\n        xLinks: xLinks,\n        yLinks: yLinks,\n        isSubplotConstrained: isSubplotConstrained\n    };\n}\n\n// still seems to be some confusion about onwheel vs onmousewheel...\nfunction attachWheelEventHandler(element, handler) {\n    if(!supportsPassive) {\n        if(element.onwheel !== undefined) element.onwheel = handler;\n        else if(element.onmousewheel !== undefined) element.onmousewheel = handler;\n        else if(!element.isAddedWheelEvent) {\n            element.isAddedWheelEvent = true;\n            element.addEventListener('wheel', handler, {passive: false});\n        }\n    } else {\n        var wheelEventName = element.onwheel !== undefined ? 'wheel' : 'mousewheel';\n\n        if(element._onwheel) {\n            element.removeEventListener(wheelEventName, element._onwheel);\n        }\n        element._onwheel = handler;\n\n        element.addEventListener(wheelEventName, handler, {passive: false});\n    }\n}\n\nfunction hashValues(hash) {\n    var out = [];\n    for(var k in hash) out.push(hash[k]);\n    return out;\n}\n\nmodule.exports = {\n    makeDragBox: makeDragBox,\n\n    makeDragger: makeDragger,\n    makeRectDragger: makeRectDragger,\n    makeZoombox: makeZoombox,\n    makeCorners: makeCorners,\n\n    updateZoombox: updateZoombox,\n    xyCorners: xyCorners,\n    transitionZoombox: transitionZoombox,\n    removeZoombox: removeZoombox,\n    showDoubleClickNotifier: showDoubleClickNotifier,\n\n    attachWheelEventHandler: attachWheelEventHandler\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\n\nvar Fx = require('../../components/fx');\nvar dragElement = require('../../components/dragelement');\nvar setCursor = require('../../lib/setcursor');\n\nvar makeDragBox = require('./dragbox').makeDragBox;\nvar DRAGGERSIZE = require('./constants').DRAGGERSIZE;\n\nexports.initInteractions = function initInteractions(gd) {\n    var fullLayout = gd._fullLayout;\n\n    if(gd._context.staticPlot) {\n        // this sweeps up more than just cartesian drag elements...\n        d3.select(gd).selectAll('.drag').remove();\n        return;\n    }\n\n    if(!fullLayout._has('cartesian') && !fullLayout._has('splom')) return;\n\n    var subplots = Object.keys(fullLayout._plots || {}).sort(function(a, b) {\n        // sort overlays last, then by x axis number, then y axis number\n        if((fullLayout._plots[a].mainplot && true) ===\n            (fullLayout._plots[b].mainplot && true)) {\n            var aParts = a.split('y');\n            var bParts = b.split('y');\n            return (aParts[0] === bParts[0]) ?\n                (Number(aParts[1] || 1) - Number(bParts[1] || 1)) :\n                (Number(aParts[0] || 1) - Number(bParts[0] || 1));\n        }\n        return fullLayout._plots[a].mainplot ? 1 : -1;\n    });\n\n    subplots.forEach(function(subplot) {\n        var plotinfo = fullLayout._plots[subplot];\n        var xa = plotinfo.xaxis;\n        var ya = plotinfo.yaxis;\n\n        // main and corner draggers need not be repeated for\n        // overlaid subplots - these draggers drag them all\n        if(!plotinfo.mainplot) {\n            // main dragger goes over the grids and data, so we use its\n            // mousemove events for all data hover effects\n            var maindrag = makeDragBox(gd, plotinfo, xa._offset, ya._offset,\n                xa._length, ya._length, 'ns', 'ew');\n\n            maindrag.onmousemove = function(evt) {\n                // This is on `gd._fullLayout`, *not* fullLayout because the reference\n                // changes by the time this is called again.\n                gd._fullLayout._rehover = function() {\n                    if((gd._fullLayout._hoversubplot === subplot) && gd._fullLayout._plots[subplot]) {\n                        Fx.hover(gd, evt, subplot);\n                    }\n                };\n\n                Fx.hover(gd, evt, subplot);\n\n                // Note that we have *not* used the cached fullLayout variable here\n                // since that may be outdated when this is called as a callback later on\n                gd._fullLayout._lasthover = maindrag;\n                gd._fullLayout._hoversubplot = subplot;\n            };\n\n            /*\n             * IMPORTANT:\n             * We must check for the presence of the drag cover here.\n             * If we don't, a 'mouseout' event is triggered on the\n             * maindrag before each 'click' event, which has the effect\n             * of clearing the hoverdata; thus, cancelling the click event.\n             */\n            maindrag.onmouseout = function(evt) {\n                if(gd._dragging) return;\n\n                // When the mouse leaves this maindrag, unset the hovered subplot.\n                // This may cause problems if it leaves the subplot directly *onto*\n                // another subplot, but that's a tiny corner case at the moment.\n                gd._fullLayout._hoversubplot = null;\n\n                dragElement.unhover(gd, evt);\n            };\n\n            // corner draggers\n            if(gd._context.showAxisDragHandles) {\n                makeDragBox(gd, plotinfo, xa._offset - DRAGGERSIZE, ya._offset - DRAGGERSIZE,\n                    DRAGGERSIZE, DRAGGERSIZE, 'n', 'w');\n                makeDragBox(gd, plotinfo, xa._offset + xa._length, ya._offset - DRAGGERSIZE,\n                    DRAGGERSIZE, DRAGGERSIZE, 'n', 'e');\n                makeDragBox(gd, plotinfo, xa._offset - DRAGGERSIZE, ya._offset + ya._length,\n                    DRAGGERSIZE, DRAGGERSIZE, 's', 'w');\n                makeDragBox(gd, plotinfo, xa._offset + xa._length, ya._offset + ya._length,\n                    DRAGGERSIZE, DRAGGERSIZE, 's', 'e');\n            }\n        }\n        if(gd._context.showAxisDragHandles) {\n            // x axis draggers - if you have overlaid plots,\n            // these drag each axis separately\n            if(subplot === xa._mainSubplot) {\n                // the y position of the main x axis line\n                var y0 = xa._mainLinePosition;\n                if(xa.side === 'top') y0 -= DRAGGERSIZE;\n                makeDragBox(gd, plotinfo, xa._offset + xa._length * 0.1, y0,\n                    xa._length * 0.8, DRAGGERSIZE, '', 'ew');\n                makeDragBox(gd, plotinfo, xa._offset, y0,\n                    xa._length * 0.1, DRAGGERSIZE, '', 'w');\n                makeDragBox(gd, plotinfo, xa._offset + xa._length * 0.9, y0,\n                    xa._length * 0.1, DRAGGERSIZE, '', 'e');\n            }\n            // y axis draggers\n            if(subplot === ya._mainSubplot) {\n                // the x position of the main y axis line\n                var x0 = ya._mainLinePosition;\n                if(ya.side !== 'right') x0 -= DRAGGERSIZE;\n                makeDragBox(gd, plotinfo, x0, ya._offset + ya._length * 0.1,\n                    DRAGGERSIZE, ya._length * 0.8, 'ns', '');\n                makeDragBox(gd, plotinfo, x0, ya._offset + ya._length * 0.9,\n                    DRAGGERSIZE, ya._length * 0.1, 's', '');\n                makeDragBox(gd, plotinfo, x0, ya._offset,\n                    DRAGGERSIZE, ya._length * 0.1, 'n', '');\n            }\n        }\n    });\n\n    // In case you mousemove over some hovertext, send it to Fx.hover too\n    // we do this so that we can put the hover text in front of everything,\n    // but still be able to interact with everything as if it isn't there\n    var hoverLayer = fullLayout._hoverlayer.node();\n\n    hoverLayer.onmousemove = function(evt) {\n        evt.target = gd._fullLayout._lasthover;\n        Fx.hover(gd, evt, fullLayout._hoversubplot);\n    };\n\n    hoverLayer.onclick = function(evt) {\n        evt.target = gd._fullLayout._lasthover;\n        Fx.click(gd, evt);\n    };\n\n    // also delegate mousedowns... TODO: does this actually work?\n    hoverLayer.onmousedown = function(evt) {\n        gd._fullLayout._lasthover.onmousedown(evt);\n    };\n\n    exports.updateFx(gd);\n};\n\n// Minimal set of update needed on 'modebar' edits.\n// We only need to update the <g .draglayer> cursor style.\n//\n// Note that changing the axis configuration and/or the fixedrange attribute\n// should trigger a full initInteractions.\nexports.updateFx = function(gd) {\n    var fullLayout = gd._fullLayout;\n    var cursor = fullLayout.dragmode === 'pan' ? 'move' : 'crosshair';\n    setCursor(fullLayout._draggers, cursor);\n};\n","'use strict';\n\nvar Registry = require('../../registry');\nvar Lib = require('../../lib');\nvar axisIds = require('./axis_ids');\n\n/**\n * Factory function for checking component arrays for subplot references.\n *\n * @param {string} containerArrayName: the top-level array in gd.layout to check\n *   If an item in this container is found that references a cartesian x and/or y axis,\n *   ensure cartesian is marked as a base plot module and record the axes (and subplot\n *   if both refs are axes) in gd._fullLayout\n *\n * @return {function}: with args layoutIn (gd.layout) and layoutOut (gd._fullLayout)\n * as expected of a component includeBasePlot method\n */\nmodule.exports = function makeIncludeComponents(containerArrayName) {\n    return function includeComponents(layoutIn, layoutOut) {\n        var array = layoutIn[containerArrayName];\n        if(!Array.isArray(array)) return;\n\n        var Cartesian = Registry.subplotsRegistry.cartesian;\n        var idRegex = Cartesian.idRegex;\n        var subplots = layoutOut._subplots;\n        var xaList = subplots.xaxis;\n        var yaList = subplots.yaxis;\n        var cartesianList = subplots.cartesian;\n        var hasCartesianOrGL2D = layoutOut._has('cartesian') || layoutOut._has('gl2d');\n\n        for(var i = 0; i < array.length; i++) {\n            var itemi = array[i];\n            if(!Lib.isPlainObject(itemi)) continue;\n\n            // call cleanId because if xref, or yref has something appended\n            // (e.g., ' domain') this will get removed.\n            var xref = axisIds.cleanId(itemi.xref, 'x', false);\n            var yref = axisIds.cleanId(itemi.yref, 'y', false);\n\n            var hasXref = idRegex.x.test(xref);\n            var hasYref = idRegex.y.test(yref);\n            if(hasXref || hasYref) {\n                if(!hasCartesianOrGL2D) Lib.pushUnique(layoutOut._basePlotModules, Cartesian);\n\n                var newAxis = false;\n                if(hasXref && xaList.indexOf(xref) === -1) {\n                    xaList.push(xref);\n                    newAxis = true;\n                }\n                if(hasYref && yaList.indexOf(yref) === -1) {\n                    yaList.push(yref);\n                    newAxis = true;\n                }\n\n                /*\n                 * Notice the logic here: only add a subplot for a component if\n                 * it's referencing both x and y axes AND it's creating a new axis\n                 * so for example if your plot already has xy and x2y2, an annotation\n                 * on x2y or xy2 will not create a new subplot.\n                 */\n                if(newAxis && hasXref && hasYref) {\n                    cartesianList.push(xref + yref);\n                }\n            }\n        }\n    };\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\n\nvar Registry = require('../../registry');\nvar Lib = require('../../lib');\nvar Plots = require('../plots');\nvar Drawing = require('../../components/drawing');\n\nvar getModuleCalcData = require('../get_data').getModuleCalcData;\nvar axisIds = require('./axis_ids');\nvar constants = require('./constants');\nvar xmlnsNamespaces = require('../../constants/xmlns_namespaces');\n\nvar ensureSingle = Lib.ensureSingle;\n\nfunction ensureSingleAndAddDatum(parent, nodeType, className) {\n    return Lib.ensureSingle(parent, nodeType, className, function(s) {\n        s.datum(className);\n    });\n}\n\nexports.name = 'cartesian';\n\nexports.attr = ['xaxis', 'yaxis'];\n\nexports.idRoot = ['x', 'y'];\n\nexports.idRegex = constants.idRegex;\n\nexports.attrRegex = constants.attrRegex;\n\nexports.attributes = require('./attributes');\n\nexports.layoutAttributes = require('./layout_attributes');\n\nexports.supplyLayoutDefaults = require('./layout_defaults');\n\nexports.transitionAxes = require('./transition_axes');\n\nexports.finalizeSubplots = function(layoutIn, layoutOut) {\n    var subplots = layoutOut._subplots;\n    var xList = subplots.xaxis;\n    var yList = subplots.yaxis;\n    var spSVG = subplots.cartesian;\n    var spAll = spSVG.concat(subplots.gl2d || []);\n    var allX = {};\n    var allY = {};\n    var i, xi, yi;\n\n    for(i = 0; i < spAll.length; i++) {\n        var parts = spAll[i].split('y');\n        allX[parts[0]] = 1;\n        allY['y' + parts[1]] = 1;\n    }\n\n    // check for x axes with no subplot, and make one from the anchor of that x axis\n    for(i = 0; i < xList.length; i++) {\n        xi = xList[i];\n        if(!allX[xi]) {\n            yi = (layoutIn[axisIds.id2name(xi)] || {}).anchor;\n            if(!constants.idRegex.y.test(yi)) yi = 'y';\n            spSVG.push(xi + yi);\n            spAll.push(xi + yi);\n\n            if(!allY[yi]) {\n                allY[yi] = 1;\n                Lib.pushUnique(yList, yi);\n            }\n        }\n    }\n\n    // same for y axes with no subplot\n    for(i = 0; i < yList.length; i++) {\n        yi = yList[i];\n        if(!allY[yi]) {\n            xi = (layoutIn[axisIds.id2name(yi)] || {}).anchor;\n            if(!constants.idRegex.x.test(xi)) xi = 'x';\n            spSVG.push(xi + yi);\n            spAll.push(xi + yi);\n\n            if(!allX[xi]) {\n                allX[xi] = 1;\n                Lib.pushUnique(xList, xi);\n            }\n        }\n    }\n\n    // finally, if we've gotten here we're supposed to show cartesian...\n    // so if there are NO subplots at all, make one from the first\n    // x & y axes in the input layout\n    if(!spAll.length) {\n        xi = '';\n        yi = '';\n        for(var ki in layoutIn) {\n            if(constants.attrRegex.test(ki)) {\n                var axLetter = ki.charAt(0);\n                if(axLetter === 'x') {\n                    if(!xi || (+ki.substr(5) < +xi.substr(5))) {\n                        xi = ki;\n                    }\n                } else if(!yi || (+ki.substr(5) < +yi.substr(5))) {\n                    yi = ki;\n                }\n            }\n        }\n        xi = xi ? axisIds.name2id(xi) : 'x';\n        yi = yi ? axisIds.name2id(yi) : 'y';\n        xList.push(xi);\n        yList.push(yi);\n        spSVG.push(xi + yi);\n    }\n};\n\n/**\n * Cartesian.plot\n *\n * @param {DOM div | object} gd\n * @param {array (optional)} traces\n *  array of traces indices to plot\n *  if undefined, plots all cartesian traces,\n * @param {object} (optional) transitionOpts\n *  transition option object\n * @param {function} (optional) makeOnCompleteCallback\n *  transition make callback function from Plots.transition\n */\nexports.plot = function(gd, traces, transitionOpts, makeOnCompleteCallback) {\n    var fullLayout = gd._fullLayout;\n    var subplots = fullLayout._subplots.cartesian;\n    var calcdata = gd.calcdata;\n    var i;\n\n    if(!Array.isArray(traces)) {\n        // If traces is not provided, then it's a complete replot and missing\n        // traces are removed\n        traces = [];\n        for(i = 0; i < calcdata.length; i++) traces.push(i);\n    }\n\n    for(i = 0; i < subplots.length; i++) {\n        var subplot = subplots[i];\n        var subplotInfo = fullLayout._plots[subplot];\n\n        // Get all calcdata for this subplot:\n        var cdSubplot = [];\n        var pcd;\n\n        for(var j = 0; j < calcdata.length; j++) {\n            var cd = calcdata[j];\n            var trace = cd[0].trace;\n\n            // Skip trace if whitelist provided and it's not whitelisted:\n            // if (Array.isArray(traces) && traces.indexOf(i) === -1) continue;\n            if(trace.xaxis + trace.yaxis === subplot) {\n                // XXX: Should trace carpet dependencies. Only replot all carpet plots if the carpet\n                // axis has actually changed:\n                //\n                // If this trace is specifically requested, add it to the list:\n                if(traces.indexOf(trace.index) !== -1 || trace.carpet) {\n                    // Okay, so example: traces 0, 1, and 2 have fill = tonext. You animate\n                    // traces 0 and 2. Trace 1 also needs to be updated, otherwise its fill\n                    // is outdated. So this retroactively adds the previous trace if the\n                    // traces are interdependent.\n                    if(\n                        pcd &&\n                        pcd[0].trace.xaxis + pcd[0].trace.yaxis === subplot &&\n                        ['tonextx', 'tonexty', 'tonext'].indexOf(trace.fill) !== -1 &&\n                        cdSubplot.indexOf(pcd) === -1\n                    ) {\n                        cdSubplot.push(pcd);\n                    }\n\n                    cdSubplot.push(cd);\n                }\n\n                // Track the previous trace on this subplot for the retroactive-add step\n                // above:\n                pcd = cd;\n            }\n        }\n\n        plotOne(gd, subplotInfo, cdSubplot, transitionOpts, makeOnCompleteCallback);\n    }\n};\n\nfunction plotOne(gd, plotinfo, cdSubplot, transitionOpts, makeOnCompleteCallback) {\n    var traceLayerClasses = constants.traceLayerClasses;\n    var fullLayout = gd._fullLayout;\n    var modules = fullLayout._modules;\n    var _module, cdModuleAndOthers, cdModule;\n\n    var layerData = [];\n    var zoomScaleQueryParts = [];\n\n    for(var i = 0; i < modules.length; i++) {\n        _module = modules[i];\n        var name = _module.name;\n        var categories = Registry.modules[name].categories;\n\n        if(categories.svg) {\n            var className = (_module.layerName || name + 'layer');\n            var plotMethod = _module.plot;\n\n            // plot all visible traces of this type on this subplot at once\n            cdModuleAndOthers = getModuleCalcData(cdSubplot, plotMethod);\n            cdModule = cdModuleAndOthers[0];\n            // don't need to search the found traces again - in fact we need to NOT\n            // so that if two modules share the same plotter we don't double-plot\n            cdSubplot = cdModuleAndOthers[1];\n\n            if(cdModule.length) {\n                layerData.push({\n                    i: traceLayerClasses.indexOf(className),\n                    className: className,\n                    plotMethod: plotMethod,\n                    cdModule: cdModule\n                });\n            }\n\n            if(categories.zoomScale) {\n                zoomScaleQueryParts.push('.' + className);\n            }\n        }\n    }\n\n    layerData.sort(function(a, b) { return a.i - b.i; });\n\n    var layers = plotinfo.plot.selectAll('g.mlayer')\n        .data(layerData, function(d) { return d.className; });\n\n    layers.enter().append('g')\n        .attr('class', function(d) { return d.className; })\n        .classed('mlayer', true)\n        .classed('rangeplot', plotinfo.isRangePlot);\n\n    layers.exit().remove();\n\n    layers.order();\n\n    layers.each(function(d) {\n        var sel = d3.select(this);\n        var className = d.className;\n\n        d.plotMethod(\n            gd, plotinfo, d.cdModule, sel,\n            transitionOpts, makeOnCompleteCallback\n        );\n\n        // layers that allow `cliponaxis: false`\n        if(constants.clipOnAxisFalseQuery.indexOf('.' + className) === -1) {\n            Drawing.setClipUrl(sel, plotinfo.layerClipId, gd);\n        }\n    });\n\n    // call Scattergl.plot separately\n    if(fullLayout._has('scattergl')) {\n        _module = Registry.getModule('scattergl');\n        cdModule = getModuleCalcData(cdSubplot, _module)[0];\n        _module.plot(gd, plotinfo, cdModule);\n    }\n\n    // stash \"hot\" selections for faster interaction on drag and scroll\n    if(!gd._context.staticPlot) {\n        if(plotinfo._hasClipOnAxisFalse) {\n            plotinfo.clipOnAxisFalseTraces = plotinfo.plot\n                .selectAll(constants.clipOnAxisFalseQuery.join(','))\n                .selectAll('.trace');\n        }\n\n        if(zoomScaleQueryParts.length) {\n            var traces = plotinfo.plot\n                .selectAll(zoomScaleQueryParts.join(','))\n                .selectAll('.trace');\n\n            plotinfo.zoomScalePts = traces.selectAll('path.point');\n            plotinfo.zoomScaleTxt = traces.selectAll('.textpoint');\n        }\n    }\n}\n\nexports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {\n    var oldPlots = oldFullLayout._plots || {};\n    var newPlots = newFullLayout._plots || {};\n    var oldSubplotList = oldFullLayout._subplots || {};\n    var plotinfo;\n    var i, k;\n\n    // when going from a large splom graph to something else,\n    // we need to clear <g subplot> so that the new cartesian subplot\n    // can have the correct layer ordering\n    if(oldFullLayout._hasOnlyLargeSploms && !newFullLayout._hasOnlyLargeSploms) {\n        for(k in oldPlots) {\n            plotinfo = oldPlots[k];\n            if(plotinfo.plotgroup) plotinfo.plotgroup.remove();\n        }\n    }\n\n    var hadGl = (oldFullLayout._has && oldFullLayout._has('gl'));\n    var hasGl = (newFullLayout._has && newFullLayout._has('gl'));\n\n    if(hadGl && !hasGl) {\n        for(k in oldPlots) {\n            plotinfo = oldPlots[k];\n            if(plotinfo._scene) plotinfo._scene.destroy();\n        }\n    }\n\n    // delete any titles we don't need anymore\n    // check if axis list has changed, and if so clear old titles\n    if(oldSubplotList.xaxis && oldSubplotList.yaxis) {\n        var oldAxIDs = axisIds.listIds({_fullLayout: oldFullLayout});\n        for(i = 0; i < oldAxIDs.length; i++) {\n            var oldAxId = oldAxIDs[i];\n            if(!newFullLayout[axisIds.id2name(oldAxId)]) {\n                oldFullLayout._infolayer.selectAll('.g-' + oldAxId + 'title').remove();\n            }\n        }\n    }\n\n    var hadCartesian = (oldFullLayout._has && oldFullLayout._has('cartesian'));\n    var hasCartesian = (newFullLayout._has && newFullLayout._has('cartesian'));\n\n    if(hadCartesian && !hasCartesian) {\n        // if we've gotten rid of all cartesian traces, remove all the subplot svg items\n\n        purgeSubplotLayers(oldFullLayout._cartesianlayer.selectAll('.subplot'), oldFullLayout);\n        oldFullLayout._defs.selectAll('.axesclip').remove();\n        delete oldFullLayout._axisConstraintGroups;\n        delete oldFullLayout._axisMatchGroups;\n    } else if(oldSubplotList.cartesian) {\n        // otherwise look for subplots we need to remove\n\n        for(i = 0; i < oldSubplotList.cartesian.length; i++) {\n            var oldSubplotId = oldSubplotList.cartesian[i];\n            if(!newPlots[oldSubplotId]) {\n                var selector = '.' + oldSubplotId + ',.' + oldSubplotId + '-x,.' + oldSubplotId + '-y';\n                oldFullLayout._cartesianlayer.selectAll(selector).remove();\n                removeSubplotExtras(oldSubplotId, oldFullLayout);\n            }\n        }\n    }\n};\n\nexports.drawFramework = function(gd) {\n    var fullLayout = gd._fullLayout;\n    var subplotData = makeSubplotData(gd);\n\n    var subplotLayers = fullLayout._cartesianlayer.selectAll('.subplot')\n        .data(subplotData, String);\n\n    subplotLayers.enter().append('g')\n        .attr('class', function(d) { return 'subplot ' + d[0]; });\n\n    subplotLayers.order();\n\n    subplotLayers.exit()\n        .call(purgeSubplotLayers, fullLayout);\n\n    subplotLayers.each(function(d) {\n        var id = d[0];\n        var plotinfo = fullLayout._plots[id];\n\n        plotinfo.plotgroup = d3.select(this);\n        makeSubplotLayer(gd, plotinfo);\n\n        // make separate drag layers for each subplot,\n        // but append them to paper rather than the plot groups,\n        // so they end up on top of the rest\n        plotinfo.draglayer = ensureSingle(fullLayout._draggers, 'g', id);\n    });\n};\n\nexports.rangePlot = function(gd, plotinfo, cdSubplot) {\n    makeSubplotLayer(gd, plotinfo);\n    plotOne(gd, plotinfo, cdSubplot);\n    Plots.style(gd);\n};\n\nfunction makeSubplotData(gd) {\n    var fullLayout = gd._fullLayout;\n    var ids = fullLayout._subplots.cartesian;\n    var len = ids.length;\n    var i, j, id, plotinfo, xa, ya;\n\n    // split 'regular' and 'overlaying' subplots\n    var regulars = [];\n    var overlays = [];\n\n    for(i = 0; i < len; i++) {\n        id = ids[i];\n        plotinfo = fullLayout._plots[id];\n        xa = plotinfo.xaxis;\n        ya = plotinfo.yaxis;\n\n        var xa2 = xa._mainAxis;\n        var ya2 = ya._mainAxis;\n        var mainplot = xa2._id + ya2._id;\n        var mainplotinfo = fullLayout._plots[mainplot];\n        plotinfo.overlays = [];\n\n        if(mainplot !== id && mainplotinfo) {\n            plotinfo.mainplot = mainplot;\n            plotinfo.mainplotinfo = mainplotinfo;\n            overlays.push(id);\n        } else {\n            plotinfo.mainplot = undefined;\n            plotinfo.mainplotinfo = undefined;\n            regulars.push(id);\n        }\n    }\n\n    // fill in list of overlaying subplots in 'main plot'\n    for(i = 0; i < overlays.length; i++) {\n        id = overlays[i];\n        plotinfo = fullLayout._plots[id];\n        plotinfo.mainplotinfo.overlays.push(plotinfo);\n    }\n\n    // put 'regular' subplot data before 'overlaying'\n    var subplotIds = regulars.concat(overlays);\n    var subplotData = new Array(len);\n\n    for(i = 0; i < len; i++) {\n        id = subplotIds[i];\n        plotinfo = fullLayout._plots[id];\n        xa = plotinfo.xaxis;\n        ya = plotinfo.yaxis;\n\n        // use info about axis layer and overlaying pattern\n        // to clean what need to be cleaned up in exit selection\n        var d = [id, xa.layer, ya.layer, xa.overlaying || '', ya.overlaying || ''];\n        for(j = 0; j < plotinfo.overlays.length; j++) {\n            d.push(plotinfo.overlays[j].id);\n        }\n        subplotData[i] = d;\n    }\n\n    return subplotData;\n}\n\nfunction makeSubplotLayer(gd, plotinfo) {\n    var plotgroup = plotinfo.plotgroup;\n    var id = plotinfo.id;\n    var xLayer = constants.layerValue2layerClass[plotinfo.xaxis.layer];\n    var yLayer = constants.layerValue2layerClass[plotinfo.yaxis.layer];\n    var hasOnlyLargeSploms = gd._fullLayout._hasOnlyLargeSploms;\n\n    if(!plotinfo.mainplot) {\n        if(hasOnlyLargeSploms) {\n            // TODO could do even better\n            // - we don't need plot (but we would have to mock it in lsInner\n            //   and other places\n            // - we don't (x|y)lines and (x|y)axislayer for most subplots\n            //   usually just the bottom x and left y axes.\n            plotinfo.xlines = ensureSingle(plotgroup, 'path', 'xlines-above');\n            plotinfo.ylines = ensureSingle(plotgroup, 'path', 'ylines-above');\n            plotinfo.xaxislayer = ensureSingle(plotgroup, 'g', 'xaxislayer-above');\n            plotinfo.yaxislayer = ensureSingle(plotgroup, 'g', 'yaxislayer-above');\n        } else {\n            var backLayer = ensureSingle(plotgroup, 'g', 'layer-subplot');\n            plotinfo.shapelayer = ensureSingle(backLayer, 'g', 'shapelayer');\n            plotinfo.imagelayer = ensureSingle(backLayer, 'g', 'imagelayer');\n\n            plotinfo.minorGridlayer = ensureSingle(plotgroup, 'g', 'minor-gridlayer');\n            plotinfo.gridlayer = ensureSingle(plotgroup, 'g', 'gridlayer');\n            plotinfo.zerolinelayer = ensureSingle(plotgroup, 'g', 'zerolinelayer');\n\n            ensureSingle(plotgroup, 'path', 'xlines-below');\n            ensureSingle(plotgroup, 'path', 'ylines-below');\n            plotinfo.overlinesBelow = ensureSingle(plotgroup, 'g', 'overlines-below');\n\n            ensureSingle(plotgroup, 'g', 'xaxislayer-below');\n            ensureSingle(plotgroup, 'g', 'yaxislayer-below');\n            plotinfo.overaxesBelow = ensureSingle(plotgroup, 'g', 'overaxes-below');\n\n            plotinfo.plot = ensureSingle(plotgroup, 'g', 'plot');\n            plotinfo.overplot = ensureSingle(plotgroup, 'g', 'overplot');\n\n            plotinfo.xlines = ensureSingle(plotgroup, 'path', 'xlines-above');\n            plotinfo.ylines = ensureSingle(plotgroup, 'path', 'ylines-above');\n            plotinfo.overlinesAbove = ensureSingle(plotgroup, 'g', 'overlines-above');\n\n            ensureSingle(plotgroup, 'g', 'xaxislayer-above');\n            ensureSingle(plotgroup, 'g', 'yaxislayer-above');\n            plotinfo.overaxesAbove = ensureSingle(plotgroup, 'g', 'overaxes-above');\n\n            // set refs to correct layers as determined by 'axis.layer'\n            plotinfo.xlines = plotgroup.select('.xlines-' + xLayer);\n            plotinfo.ylines = plotgroup.select('.ylines-' + yLayer);\n            plotinfo.xaxislayer = plotgroup.select('.xaxislayer-' + xLayer);\n            plotinfo.yaxislayer = plotgroup.select('.yaxislayer-' + yLayer);\n        }\n    } else {\n        var mainplotinfo = plotinfo.mainplotinfo;\n        var mainplotgroup = mainplotinfo.plotgroup;\n        var xId = id + '-x';\n        var yId = id + '-y';\n\n        // now make the components of overlaid subplots\n        // overlays don't have backgrounds, and append all\n        // their other components to the corresponding\n        // extra groups of their main plots.\n\n        plotinfo.minorGridlayer = mainplotinfo.minorGridlayer;\n        plotinfo.gridlayer = mainplotinfo.gridlayer;\n        plotinfo.zerolinelayer = mainplotinfo.zerolinelayer;\n\n        ensureSingle(mainplotinfo.overlinesBelow, 'path', xId);\n        ensureSingle(mainplotinfo.overlinesBelow, 'path', yId);\n        ensureSingle(mainplotinfo.overaxesBelow, 'g', xId);\n        ensureSingle(mainplotinfo.overaxesBelow, 'g', yId);\n\n        plotinfo.plot = ensureSingle(mainplotinfo.overplot, 'g', id);\n\n        ensureSingle(mainplotinfo.overlinesAbove, 'path', xId);\n        ensureSingle(mainplotinfo.overlinesAbove, 'path', yId);\n        ensureSingle(mainplotinfo.overaxesAbove, 'g', xId);\n        ensureSingle(mainplotinfo.overaxesAbove, 'g', yId);\n\n        // set refs to correct layers as determined by 'abovetraces'\n        plotinfo.xlines = mainplotgroup.select('.overlines-' + xLayer).select('.' + xId);\n        plotinfo.ylines = mainplotgroup.select('.overlines-' + yLayer).select('.' + yId);\n        plotinfo.xaxislayer = mainplotgroup.select('.overaxes-' + xLayer).select('.' + xId);\n        plotinfo.yaxislayer = mainplotgroup.select('.overaxes-' + yLayer).select('.' + yId);\n    }\n\n    // common attributes for all subplots, overlays or not\n\n    if(!hasOnlyLargeSploms) {\n        ensureSingleAndAddDatum(plotinfo.minorGridlayer, 'g', plotinfo.xaxis._id);\n        ensureSingleAndAddDatum(plotinfo.minorGridlayer, 'g', plotinfo.yaxis._id);\n        plotinfo.minorGridlayer.selectAll('g')\n            .map(function(d) { return d[0]; })\n            .sort(axisIds.idSort);\n\n        ensureSingleAndAddDatum(plotinfo.gridlayer, 'g', plotinfo.xaxis._id);\n        ensureSingleAndAddDatum(plotinfo.gridlayer, 'g', plotinfo.yaxis._id);\n        plotinfo.gridlayer.selectAll('g')\n            .map(function(d) { return d[0]; })\n            .sort(axisIds.idSort);\n    }\n\n    plotinfo.xlines\n        .style('fill', 'none')\n        .classed('crisp', true);\n\n    plotinfo.ylines\n        .style('fill', 'none')\n        .classed('crisp', true);\n}\n\nfunction purgeSubplotLayers(layers, fullLayout) {\n    if(!layers) return;\n\n    var overlayIdsToRemove = {};\n\n    layers.each(function(d) {\n        var id = d[0];\n        var plotgroup = d3.select(this);\n\n        plotgroup.remove();\n        removeSubplotExtras(id, fullLayout);\n        overlayIdsToRemove[id] = true;\n\n        // do not remove individual axis <clipPath>s here\n        // as other subplots may need them\n    });\n\n    // must remove overlaid subplot trace layers 'manually'\n\n    for(var k in fullLayout._plots) {\n        var subplotInfo = fullLayout._plots[k];\n        var overlays = subplotInfo.overlays || [];\n\n        for(var j = 0; j < overlays.length; j++) {\n            var overlayInfo = overlays[j];\n\n            if(overlayIdsToRemove[overlayInfo.id]) {\n                overlayInfo.plot.selectAll('.trace').remove();\n            }\n        }\n    }\n}\n\nfunction removeSubplotExtras(subplotId, fullLayout) {\n    fullLayout._draggers.selectAll('g.' + subplotId).remove();\n    fullLayout._defs.select('#clip' + fullLayout._uid + subplotId + 'plot').remove();\n}\n\nexports.toSVG = function(gd) {\n    var imageRoot = gd._fullLayout._glimages;\n    var root = d3.select(gd).selectAll('.svg-container');\n    var canvases = root.filter(function(d, i) {return i === root.size() - 1;})\n        .selectAll('.gl-canvas-context, .gl-canvas-focus');\n\n    function canvasToImage() {\n        var canvas = this;\n        var imageData = canvas.toDataURL('image/png');\n        var image = imageRoot.append('svg:image');\n\n        image.attr({\n            xmlns: xmlnsNamespaces.svg,\n            'xlink:href': imageData,\n            preserveAspectRatio: 'none',\n            x: 0,\n            y: 0,\n            width: canvas.style.width,\n            height: canvas.style.height\n        });\n    }\n\n    canvases.each(canvasToImage);\n};\n\nexports.updateFx = require('./graph_interact').updateFx;\n","'use strict';\n\nvar fontAttrs = require('../font_attributes');\nvar colorAttrs = require('../../components/color/attributes');\nvar dash = require('../../components/drawing/attributes').dash;\nvar extendFlat = require('../../lib/extend').extendFlat;\nvar templatedArray = require('../../plot_api/plot_template').templatedArray;\nvar descriptionWithDates = require('../../plots/cartesian/axis_format_attributes').descriptionWithDates;\n\nvar ONEDAY = require('../../constants/numerical').ONEDAY;\nvar constants = require('./constants');\nvar HOUR = constants.HOUR_PATTERN;\nvar DAY_OF_WEEK = constants.WEEKDAY_PATTERN;\n\nvar minorTickmode = {\n    valType: 'enumerated',\n    values: ['auto', 'linear', 'array'],\n    editType: 'ticks',\n    impliedEdits: {tick0: undefined, dtick: undefined},\n    description: [\n        'Sets the tick mode for this axis.',\n        'If *auto*, the number of ticks is set via `nticks`.',\n        'If *linear*, the placement of the ticks is determined by',\n        'a starting position `tick0` and a tick step `dtick`',\n        '(*linear* is the default value if `tick0` and `dtick` are provided).',\n        'If *array*, the placement of the ticks is set via `tickvals`',\n        'and the tick text is `ticktext`.',\n        '(*array* is the default value if `tickvals` is provided).'\n    ].join(' ')\n};\n\nvar tickmode = extendFlat({}, minorTickmode, {\n    values: minorTickmode.values.slice().concat(['sync']),\n    description: [\n        minorTickmode.description,\n        'If *sync*, the number of ticks will sync with the overlayed axis',\n        'set by `overlaying` property.'\n    ].join(' ')\n});\n\nfunction makeNticks(minor) {\n    return {\n        valType: 'integer',\n        min: 0,\n        dflt: minor ? 5 : 0,\n        editType: 'ticks',\n        description: [\n            'Specifies the maximum number of ticks for the particular axis.',\n            'The actual number of ticks will be chosen automatically to be',\n            'less than or equal to `nticks`.',\n            'Has an effect only if `tickmode` is set to *auto*.'\n        ].join(' ')\n    };\n}\n\nvar tick0 = {\n    valType: 'any',\n    editType: 'ticks',\n    impliedEdits: {tickmode: 'linear'},\n    description: [\n        'Sets the placement of the first tick on this axis.',\n        'Use with `dtick`.',\n        'If the axis `type` is *log*, then you must take the log of your starting tick',\n        '(e.g. to set the starting tick to 100, set the `tick0` to 2)',\n        'except when `dtick`=*L<f>* (see `dtick` for more info).',\n        'If the axis `type` is *date*, it should be a date string, like date data.',\n        'If the axis `type` is *category*, it should be a number, using the scale where',\n        'each category is assigned a serial number from zero in the order it appears.'\n    ].join(' ')\n};\n\nvar dtick = {\n    valType: 'any',\n    editType: 'ticks',\n    impliedEdits: {tickmode: 'linear'},\n    description: [\n        'Sets the step in-between ticks on this axis. Use with `tick0`.',\n        'Must be a positive number, or special strings available to *log* and *date* axes.',\n        'If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n',\n        'is the tick number. For example,',\n        'to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1.',\n        'To set tick marks at 1, 100, 10000, ... set dtick to 2.',\n        'To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433.',\n        '*log* has several special values; *L<f>*, where `f` is a positive number,',\n        'gives ticks linearly spaced in value (but not position).',\n        'For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc.',\n        'To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5).',\n        '`tick0` is ignored for *D1* and *D2*.',\n        'If the axis `type` is *date*, then you must convert the time to milliseconds.',\n        'For example, to set the interval between ticks to one day,',\n        'set `dtick` to 86400000.0.',\n        '*date* also has special values *M<n>* gives ticks spaced by a number of months.',\n        '`n` must be a positive integer.',\n        'To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*.',\n        'To set ticks every 4 years, set `dtick` to *M48*'\n    ].join(' ')\n};\n\nvar tickvals = {\n    valType: 'data_array',\n    editType: 'ticks',\n    description: [\n        'Sets the values at which ticks on this axis appear.',\n        'Only has an effect if `tickmode` is set to *array*.',\n        'Used with `ticktext`.'\n    ].join(' ')\n};\n\nvar ticks = {\n    valType: 'enumerated',\n    values: ['outside', 'inside', ''],\n    editType: 'ticks',\n    description: [\n        'Determines whether ticks are drawn or not.',\n        'If **, this axis\\' ticks are not drawn.',\n        'If *outside* (*inside*), this axis\\' are drawn outside (inside)',\n        'the axis lines.'\n    ].join(' ')\n};\n\nfunction makeTicklen(minor) {\n    var obj = {\n        valType: 'number',\n        min: 0,\n        editType: 'ticks',\n        description: 'Sets the tick length (in px).'\n    };\n\n    if(!minor) obj.dflt = 5;\n\n    return obj;\n}\n\nfunction makeTickwidth(minor) {\n    var obj = {\n        valType: 'number',\n        min: 0,\n        editType: 'ticks',\n        description: 'Sets the tick width (in px).'\n    };\n\n    if(!minor) obj.dflt = 1;\n\n    return obj;\n}\n\nvar tickcolor = {\n    valType: 'color',\n    dflt: colorAttrs.defaultLine,\n    editType: 'ticks',\n    description: 'Sets the tick color.'\n};\n\nvar gridcolor = {\n    valType: 'color',\n    dflt: colorAttrs.lightLine,\n    editType: 'ticks',\n    description: 'Sets the color of the grid lines.'\n};\n\nfunction makeGridwidth(minor) {\n    var obj = {\n        valType: 'number',\n        min: 0,\n        editType: 'ticks',\n        description: 'Sets the width (in px) of the grid lines.'\n    };\n\n    if(!minor) obj.dflt = 1;\n\n    return obj;\n}\n\nvar griddash = extendFlat({}, dash, {editType: 'ticks'});\n\nvar showgrid = {\n    valType: 'boolean',\n    editType: 'ticks',\n    description: [\n        'Determines whether or not grid lines are drawn.',\n        'If *true*, the grid lines are drawn at every tick mark.'\n    ].join(' ')\n};\n\nmodule.exports = {\n    visible: {\n        valType: 'boolean',\n        editType: 'plot',\n        description: [\n            'A single toggle to hide the axis while preserving interaction like dragging.',\n            'Default is true when a cheater plot is present on the axis, otherwise',\n            'false'\n        ].join(' ')\n    },\n    color: {\n        valType: 'color',\n        dflt: colorAttrs.defaultLine,\n        editType: 'ticks',\n        description: [\n            'Sets default for all colors associated with this axis',\n            'all at once: line, font, tick, and grid colors.',\n            'Grid color is lightened by blending this with the plot background',\n            'Individual pieces can override this.'\n        ].join(' ')\n    },\n    title: {\n        text: {\n            valType: 'string',\n            editType: 'ticks',\n            description: [\n                'Sets the title of this axis.',\n                'Note that before the existence of `title.text`, the title\\'s',\n                'contents used to be defined as the `title` attribute itself.',\n                'This behavior has been deprecated.'\n            ].join(' ')\n        },\n        font: fontAttrs({\n            editType: 'ticks',\n            description: [\n                'Sets this axis\\' title font.',\n                'Note that the title\\'s font used to be customized',\n                'by the now deprecated `titlefont` attribute.'\n            ].join(' ')\n        }),\n        standoff: {\n            valType: 'number',\n            min: 0,\n            editType: 'ticks',\n            description: [\n                'Sets the standoff distance (in px) between the axis labels and the title text',\n                'The default value is a function of the axis tick labels, the title `font.size`',\n                'and the axis `linewidth`.',\n                'Note that the axis title position is always constrained within the margins,',\n                'so the actual standoff distance is always less than the set or default value.',\n                'By setting `standoff` and turning on `automargin`, plotly.js will push the',\n                'margins to fit the axis title at given standoff distance.'\n            ].join(' ')\n        },\n        editType: 'ticks'\n    },\n    type: {\n        valType: 'enumerated',\n        // '-' means we haven't yet run autotype or couldn't find any data\n        // it gets turned into linear in gd._fullLayout but not copied back\n        // to gd.data like the others are.\n        values: ['-', 'linear', 'log', 'date', 'category', 'multicategory'],\n        dflt: '-',\n        editType: 'calc',\n        // we forget when an axis has been autotyped, just writing the auto\n        // value back to the input - so it doesn't make sense to template this.\n        // Note: we do NOT prohibit this in `coerce`, so if someone enters a\n        // type in the template explicitly it will be honored as the default.\n        _noTemplating: true,\n        description: [\n            'Sets the axis type.',\n            'By default, plotly attempts to determined the axis type',\n            'by looking into the data of the traces that referenced',\n            'the axis in question.'\n        ].join(' ')\n    },\n    autotypenumbers: {\n        valType: 'enumerated',\n        values: ['convert types', 'strict'],\n        dflt: 'convert types',\n        editType: 'calc',\n        description: [\n            'Using *strict* a numeric string in trace data is not converted to a number.',\n            'Using *convert types* a numeric string in trace data may be',\n            'treated as a number during automatic axis `type` detection.',\n            'Defaults to layout.autotypenumbers.'\n        ].join(' ')\n    },\n    autorange: {\n        valType: 'enumerated',\n        values: [true, false, 'reversed', 'min reversed', 'max reversed', 'min', 'max'],\n        dflt: true,\n        editType: 'axrange',\n        impliedEdits: {'range[0]': undefined, 'range[1]': undefined},\n        description: [\n            'Determines whether or not the range of this axis is',\n            'computed in relation to the input data.',\n            'See `rangemode` for more info.',\n            'If `range` is provided and it has a value for both the',\n            'lower and upper bound, `autorange` is set to *false*.',\n            'Using *min* applies autorange only to set the minimum.',\n            'Using *max* applies autorange only to set the maximum.',\n            'Using *min reversed* applies autorange only to set the minimum on a reversed axis.',\n            'Using *max reversed* applies autorange only to set the maximum on a reversed axis.',\n            'Using *reversed* applies autorange on both ends and reverses the axis direction.',\n        ].join(' ')\n    },\n    autorangeoptions: {\n        minallowed: {\n            valType: 'any',\n            editType: 'plot',\n            impliedEdits: {'range[0]': undefined, 'range[1]': undefined},\n            description: [\n                'Use this value exactly as autorange minimum.'\n            ].join(' ')\n        },\n        maxallowed: {\n            valType: 'any',\n            editType: 'plot',\n            impliedEdits: {'range[0]': undefined, 'range[1]': undefined},\n            description: [\n                'Use this value exactly as autorange maximum.'\n            ].join(' ')\n        },\n        clipmin: {\n            valType: 'any',\n            editType: 'plot',\n            impliedEdits: {'range[0]': undefined, 'range[1]': undefined},\n            description: [\n                'Clip autorange minimum if it goes beyond this value.',\n                'Has no effect when `autorangeoptions.minallowed` is provided.'\n            ].join(' ')\n        },\n        clipmax: {\n            valType: 'any',\n            editType: 'plot',\n            impliedEdits: {'range[0]': undefined, 'range[1]': undefined},\n            description: [\n                'Clip autorange maximum if it goes beyond this value.',\n                'Has no effect when `autorangeoptions.maxallowed` is provided.'\n            ].join(' ')\n        },\n        include: {\n            valType: 'any',\n            arrayOk: true,\n            editType: 'plot',\n            impliedEdits: {'range[0]': undefined, 'range[1]': undefined},\n            description: [\n                'Ensure this value is included in autorange.'\n            ].join(' ')\n        },\n        editType: 'plot'\n    },\n    rangemode: {\n        valType: 'enumerated',\n        values: ['normal', 'tozero', 'nonnegative'],\n        dflt: 'normal',\n        editType: 'plot',\n        description: [\n            'If *normal*, the range is computed in relation to the extrema',\n            'of the input data.',\n            'If *tozero*`, the range extends to 0,',\n            'regardless of the input data',\n            'If *nonnegative*, the range is non-negative,',\n            'regardless of the input data.',\n            'Applies only to linear axes.'\n        ].join(' ')\n    },\n    range: {\n        valType: 'info_array',\n        items: [\n            {valType: 'any', editType: 'axrange', impliedEdits: {'^autorange': false}, anim: true},\n            {valType: 'any', editType: 'axrange', impliedEdits: {'^autorange': false}, anim: true}\n        ],\n        editType: 'axrange',\n        impliedEdits: {autorange: false},\n        anim: true,\n        description: [\n            'Sets the range of this axis.',\n            'If the axis `type` is *log*, then you must take the log of your',\n            'desired range (e.g. to set the range from 1 to 100,',\n            'set the range from 0 to 2).',\n            'If the axis `type` is *date*, it should be date strings,',\n            'like date data, though Date objects and unix milliseconds',\n            'will be accepted and converted to strings.',\n            'If the axis `type` is *category*, it should be numbers,',\n            'using the scale where each category is assigned a serial',\n            'number from zero in the order it appears.',\n            'Leaving either or both elements `null` impacts the default `autorange`.',\n        ].join(' ')\n    },\n    minallowed: {\n        valType: 'any',\n        editType: 'plot',\n        impliedEdits: {'^autorange': false},\n        description: [\n            'Determines the minimum range of this axis.'\n        ].join(' ')\n    },\n    maxallowed: {\n        valType: 'any',\n        editType: 'plot',\n        impliedEdits: {'^autorange': false},\n        description: [\n            'Determines the maximum range of this axis.'\n        ].join(' ')\n    },\n    fixedrange: {\n        valType: 'boolean',\n        dflt: false,\n        editType: 'calc',\n        description: [\n            'Determines whether or not this axis is zoom-able.',\n            'If true, then zoom is disabled.'\n        ].join(' ')\n    },\n    insiderange: {\n        valType: 'info_array',\n        items: [\n            {valType: 'any', editType: 'plot'},\n            {valType: 'any', editType: 'plot'}\n        ],\n        editType: 'plot',\n        description: [\n            'Could be used to set the desired inside range of this axis',\n            '(excluding the labels) when `ticklabelposition` of',\n            'the anchored axis has *inside*.',\n            'Not implemented for axes with `type` *log*.',\n            'This would be ignored when `range` is provided.'\n        ].join(' ')\n    },\n    // scaleanchor: not used directly, just put here for reference\n    // values are any opposite-letter axis id, or `false`.\n    scaleanchor: {\n        valType: 'enumerated',\n        values: [\n            constants.idRegex.x.toString(),\n            constants.idRegex.y.toString(),\n            false\n        ],\n        editType: 'plot',\n        description: [\n            'If set to another axis id (e.g. `x2`, `y`), the range of this axis',\n            'changes together with the range of the corresponding axis',\n            'such that the scale of pixels per unit is in a constant ratio.',\n            'Both axes are still zoomable, but when you zoom one, the other will',\n            'zoom the same amount, keeping a fixed midpoint.',\n            '`constrain` and `constraintoward` determine how we enforce the constraint.',\n            'You can chain these, ie `yaxis: {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}`',\n            'but you can only link axes of the same `type`.',\n            'The linked axis can have the opposite letter (to constrain the aspect ratio)',\n            'or the same letter (to match scales across subplots).',\n            'Loops (`yaxis: {scaleanchor: *x*}, xaxis: {scaleanchor: *y*}` or longer) are redundant',\n            'and the last constraint encountered will be ignored to avoid possible',\n            'inconsistent constraints via `scaleratio`.',\n            'Note that setting axes simultaneously in both a `scaleanchor` and a `matches` constraint',\n            'is currently forbidden.',\n            'Setting `false` allows to remove a default constraint (occasionally,',\n            'you may need to prevent a default `scaleanchor` constraint from',\n            'being applied, eg. when having an image trace `yaxis: {scaleanchor: \"x\"}`',\n            'is set automatically in order for pixels to be rendered as squares,',\n            'setting `yaxis: {scaleanchor: false}` allows to remove the constraint).'\n        ].join(' ')\n    },\n    scaleratio: {\n        valType: 'number',\n        min: 0,\n        dflt: 1,\n        editType: 'plot',\n        description: [\n            'If this axis is linked to another by `scaleanchor`, this determines the pixel',\n            'to unit scale ratio. For example, if this value is 10, then every unit on',\n            'this axis spans 10 times the number of pixels as a unit on the linked axis.',\n            'Use this for example to create an elevation profile where the vertical scale',\n            'is exaggerated a fixed amount with respect to the horizontal.'\n        ].join(' ')\n    },\n    constrain: {\n        valType: 'enumerated',\n        values: ['range', 'domain'],\n        editType: 'plot',\n        description: [\n            'If this axis needs to be compressed (either due to its own `scaleanchor` and',\n            '`scaleratio` or those of the other axis), determines how that happens:',\n            'by increasing the *range*, or by decreasing the *domain*.',\n            'Default is *domain* for axes containing image traces, *range* otherwise.'\n        ].join(' ')\n    },\n    // constraintoward: not used directly, just put here for reference\n    constraintoward: {\n        valType: 'enumerated',\n        values: ['left', 'center', 'right', 'top', 'middle', 'bottom'],\n        editType: 'plot',\n        description: [\n            'If this axis needs to be compressed (either due to its own `scaleanchor` and',\n            '`scaleratio` or those of the other axis), determines which direction we push',\n            'the originally specified plot area. Options are *left*, *center* (default),',\n            'and *right* for x axes, and *top*, *middle* (default), and *bottom* for y axes.'\n        ].join(' ')\n    },\n    matches: {\n        valType: 'enumerated',\n        values: [\n            constants.idRegex.x.toString(),\n            constants.idRegex.y.toString()\n        ],\n        editType: 'calc',\n        description: [\n            'If set to another axis id (e.g. `x2`, `y`), the range of this axis',\n            'will match the range of the corresponding axis in data-coordinates space.',\n            'Moreover, matching axes share auto-range values, category lists and',\n            'histogram auto-bins.',\n            'Note that setting axes simultaneously in both a `scaleanchor` and a `matches` constraint',\n            'is currently forbidden.',\n            'Moreover, note that matching axes must have the same `type`.'\n        ].join(' ')\n    },\n\n    rangebreaks: templatedArray('rangebreak', {\n        enabled: {\n            valType: 'boolean',\n            dflt: true,\n            editType: 'calc',\n            description: [\n                'Determines whether this axis rangebreak is enabled or disabled.',\n                'Please note that `rangebreaks` only work for *date* axis type.'\n            ].join(' ')\n        },\n\n        bounds: {\n            valType: 'info_array',\n            items: [\n                {valType: 'any', editType: 'calc'},\n                {valType: 'any', editType: 'calc'}\n            ],\n            editType: 'calc',\n            description: [\n                'Sets the lower and upper bounds of this axis rangebreak.',\n                'Can be used with `pattern`.'\n            ].join(' ')\n        },\n\n        pattern: {\n            valType: 'enumerated',\n            values: [DAY_OF_WEEK, HOUR, ''],\n            editType: 'calc',\n            description: [\n                'Determines a pattern on the time line that generates breaks.',\n                'If *' + DAY_OF_WEEK + '* - days of the week in English e.g. \\'Sunday\\' or `\\sun\\`',\n                '(matching is case-insensitive and considers only the first three characters),',\n                'as well as Sunday-based integers between 0 and 6.',\n                'If *' + HOUR + '* - hour (24-hour clock) as decimal numbers between 0 and 24.',\n                'for more info.',\n                'Examples:',\n                '- { pattern: \\'' + DAY_OF_WEEK + '\\', bounds: [6, 1] }',\n                ' or simply { bounds: [\\'sat\\', \\'mon\\'] }',\n                '  breaks from Saturday to Monday (i.e. skips the weekends).',\n                '- { pattern: \\'' + HOUR + '\\', bounds: [17, 8] }',\n                '  breaks from 5pm to 8am (i.e. skips non-work hours).'\n            ].join(' ')\n        },\n\n        values: {\n            valType: 'info_array',\n            freeLength: true,\n            editType: 'calc',\n            items: {\n                valType: 'any',\n                editType: 'calc'\n            },\n            description: [\n                'Sets the coordinate values corresponding to the rangebreaks.',\n                'An alternative to `bounds`.',\n                'Use `dvalue` to set the size of the values along the axis.'\n            ].join(' ')\n        },\n        dvalue: {\n            // TODO could become 'any' to add support for 'months', 'years'\n            valType: 'number',\n            editType: 'calc',\n            min: 0,\n            dflt: ONEDAY,\n            description: [\n                'Sets the size of each `values` item.',\n                'The default is one day in milliseconds.'\n            ].join(' ')\n        },\n\n        /*\n        gap: {\n            valType: 'number',\n            min: 0,\n            dflt: 0, // for *date* axes, maybe something else for *linear*\n            editType: 'calc',\n            description: [\n                'Sets the gap distance between the start and the end of this rangebreak.',\n                'Use with `gapmode` to set the unit of measurement.'\n            ].join(' ')\n        },\n        gapmode: {\n            valType: 'enumerated',\n            values: ['pixels', 'fraction'],\n            dflt: 'pixels',\n            editType: 'calc',\n            description: [\n                'Determines if the `gap` value corresponds to a pixel length',\n                'or a fraction of the plot area.'\n            ].join(' ')\n        },\n        */\n\n        // To complete https://github.com/plotly/plotly.js/issues/4210\n        // we additionally need `gap` and make this work on *linear*, and\n        // possibly all other cartesian axis types. We possibly would also need\n        // some style attributes controlling the zig-zag on the corresponding\n        // axis.\n\n        editType: 'calc'\n    }),\n\n    // ticks\n    tickmode: tickmode,\n    nticks: makeNticks(),\n    tick0: tick0,\n    dtick: dtick,\n    ticklabelstep: {\n        valType: 'integer',\n        min: 1,\n        dflt: 1,\n        editType: 'ticks',\n        description: [\n            'Sets the spacing between tick labels as compared to the spacing between ticks.',\n            'A value of 1 (default) means each tick gets a label.',\n            'A value of 2 means shows every 2nd label.',\n            'A larger value n means only every nth tick is labeled.',\n            '`tick0` determines which labels are shown.',\n            'Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.'\n        ].join(' ')\n    },\n    tickvals: tickvals,\n    ticktext: {\n        valType: 'data_array',\n        editType: 'ticks',\n        description: [\n            'Sets the text displayed at the ticks position via `tickvals`.',\n            'Only has an effect if `tickmode` is set to *array*.',\n            'Used with `tickvals`.'\n        ].join(' ')\n    },\n    ticks: ticks,\n    tickson: {\n        valType: 'enumerated',\n        values: ['labels', 'boundaries'],\n        dflt: 'labels',\n        editType: 'ticks',\n        description: [\n            'Determines where ticks and grid lines are drawn with respect to their',\n            'corresponding tick labels.',\n            'Only has an effect for axes of `type` *category* or *multicategory*.',\n            'When set to *boundaries*, ticks and grid lines are drawn half a category',\n            'to the left/bottom of labels.'\n        ].join(' ')\n    },\n    ticklabelmode: {\n        valType: 'enumerated',\n        values: ['instant', 'period'],\n        dflt: 'instant',\n        editType: 'ticks',\n        description: [\n            'Determines where tick labels are drawn with respect to their',\n            'corresponding ticks and grid lines.',\n            'Only has an effect for axes of `type` *date*',\n            'When set to *period*, tick labels are drawn in the middle of the period',\n            'between ticks.'\n        ].join(' ')\n    },\n    // ticklabelposition: not used directly, as values depend on direction (similar to side)\n    // left/right options are for x axes, and top/bottom options are for y axes\n    ticklabelposition: {\n        valType: 'enumerated',\n        values: [\n            'outside', 'inside',\n            'outside top', 'inside top',\n            'outside left', 'inside left',\n            'outside right', 'inside right',\n            'outside bottom', 'inside bottom'\n        ],\n        dflt: 'outside',\n        editType: 'calc',\n        description: [\n            'Determines where tick labels are drawn with respect to the axis',\n            'Please note that',\n            'top or bottom has no effect on x axes or when `ticklabelmode` is set to *period*.',\n            'Similarly',\n            'left or right has no effect on y axes or when `ticklabelmode` is set to *period*.',\n            'Has no effect on *multicategory* axes or when `tickson` is set to *boundaries*.',\n            'When used on axes linked by `matches` or `scaleanchor`,',\n            'no extra padding for inside labels would be added by autorange,',\n            'so that the scales could match.'\n        ].join(' ')\n    },\n    ticklabeloverflow: {\n        valType: 'enumerated',\n        values: [\n            'allow',\n            'hide past div',\n            'hide past domain'\n        ],\n        editType: 'calc',\n        description: [\n            'Determines how we handle tick labels that would overflow either the graph div or the domain of the axis.',\n            'The default value for inside tick labels is *hide past domain*.',\n            'Otherwise on *category* and *multicategory* axes the default is *allow*.',\n            'In other cases the default is *hide past div*.'\n        ].join(' ')\n    },\n    mirror: {\n        valType: 'enumerated',\n        values: [true, 'ticks', false, 'all', 'allticks'],\n        dflt: false,\n        editType: 'ticks+layoutstyle',\n        description: [\n            'Determines if the axis lines or/and ticks are mirrored to',\n            'the opposite side of the plotting area.',\n            'If *true*, the axis lines are mirrored.',\n            'If *ticks*, the axis lines and ticks are mirrored.',\n            'If *false*, mirroring is disable.',\n            'If *all*, axis lines are mirrored on all shared-axes subplots.',\n            'If *allticks*, axis lines and ticks are mirrored',\n            'on all shared-axes subplots.'\n        ].join(' ')\n    },\n    ticklen: makeTicklen(),\n    tickwidth: makeTickwidth(),\n    tickcolor: tickcolor,\n    showticklabels: {\n        valType: 'boolean',\n        dflt: true,\n        editType: 'ticks',\n        description: 'Determines whether or not the tick labels are drawn.'\n    },\n    labelalias: {\n        valType: 'any',\n        dflt: false,\n        editType: 'ticks',\n        description: [\n            'Replacement text for specific tick or hover labels.',\n            'For example using {US: \\'USA\\', CA: \\'Canada\\'} changes US to USA',\n            'and CA to Canada. The labels we would have shown must match',\n            'the keys exactly, after adding any tickprefix or ticksuffix.',\n            'For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash.',\n            'That means you need to use −1 instead of -1.',\n            'labelalias can be used with any axis type, and both keys (if needed)',\n            'and values (if desired) can include html-like tags or MathJax.'\n        ].join(' ')\n    },\n    automargin: {\n        valType: 'flaglist',\n        flags: ['height', 'width', 'left', 'right', 'top', 'bottom'],\n        extras: [true, false],\n        dflt: false,\n        editType: 'ticks',\n        description: [\n            'Determines whether long tick labels automatically grow the figure',\n            'margins.'\n        ].join(' ')\n    },\n    showspikes: {\n        valType: 'boolean',\n        dflt: false,\n        editType: 'modebar',\n        description: [\n            'Determines whether or not spikes (aka droplines) are drawn for this axis.',\n            'Note: This only takes affect when hovermode = closest'\n        ].join(' ')\n    },\n    spikecolor: {\n        valType: 'color',\n        dflt: null,\n        editType: 'none',\n        description: 'Sets the spike color. If undefined, will use the series color'\n    },\n    spikethickness: {\n        valType: 'number',\n        dflt: 3,\n        editType: 'none',\n        description: 'Sets the width (in px) of the zero line.'\n    },\n    spikedash: extendFlat({}, dash, {dflt: 'dash', editType: 'none'}),\n    spikemode: {\n        valType: 'flaglist',\n        flags: ['toaxis', 'across', 'marker'],\n        dflt: 'toaxis',\n        editType: 'none',\n        description: [\n            'Determines the drawing mode for the spike line',\n            'If *toaxis*, the line is drawn from the data point to the axis the ',\n            'series is plotted on.',\n\n            'If *across*, the line is drawn across the entire plot area, and',\n            'supercedes *toaxis*.',\n\n            'If *marker*, then a marker dot is drawn on the axis the series is',\n            'plotted on'\n        ].join(' ')\n    },\n    spikesnap: {\n        valType: 'enumerated',\n        values: ['data', 'cursor', 'hovered data'],\n        dflt: 'hovered data',\n        editType: 'none',\n        description: 'Determines whether spikelines are stuck to the cursor or to the closest datapoints.'\n    },\n    tickfont: fontAttrs({\n        editType: 'ticks',\n        description: 'Sets the tick font.'\n    }),\n    tickangle: {\n        valType: 'angle',\n        dflt: 'auto',\n        editType: 'ticks',\n        description: [\n            'Sets the angle of the tick labels with respect to the horizontal.',\n            'For example, a `tickangle` of -90 draws the tick labels',\n            'vertically.'\n        ].join(' ')\n    },\n    autotickangles: {\n        valType: 'info_array',\n        freeLength: true,\n        items: {\n            valType: 'angle'\n        },\n        dflt: [0, 30, 90],\n        editType: 'ticks',\n        description: [\n            'When `tickangle` is set to *auto*, it will be set to the first',\n            'angle in this array that is large enough to prevent label',\n            'overlap.'\n        ].join(' ')\n    },\n    tickprefix: {\n        valType: 'string',\n        dflt: '',\n        editType: 'ticks',\n        description: 'Sets a tick label prefix.'\n    },\n    showtickprefix: {\n        valType: 'enumerated',\n        values: ['all', 'first', 'last', 'none'],\n        dflt: 'all',\n        editType: 'ticks',\n        description: [\n            'If *all*, all tick labels are displayed with a prefix.',\n            'If *first*, only the first tick is displayed with a prefix.',\n            'If *last*, only the last tick is displayed with a suffix.',\n            'If *none*, tick prefixes are hidden.'\n        ].join(' ')\n    },\n    ticksuffix: {\n        valType: 'string',\n        dflt: '',\n        editType: 'ticks',\n        description: 'Sets a tick label suffix.'\n    },\n    showticksuffix: {\n        valType: 'enumerated',\n        values: ['all', 'first', 'last', 'none'],\n        dflt: 'all',\n        editType: 'ticks',\n        description: 'Same as `showtickprefix` but for tick suffixes.'\n    },\n    showexponent: {\n        valType: 'enumerated',\n        values: ['all', 'first', 'last', 'none'],\n        dflt: 'all',\n        editType: 'ticks',\n        description: [\n            'If *all*, all exponents are shown besides their significands.',\n            'If *first*, only the exponent of the first tick is shown.',\n            'If *last*, only the exponent of the last tick is shown.',\n            'If *none*, no exponents appear.'\n        ].join(' ')\n    },\n    exponentformat: {\n        valType: 'enumerated',\n        values: ['none', 'e', 'E', 'power', 'SI', 'B'],\n        dflt: 'B',\n        editType: 'ticks',\n        description: [\n            'Determines a formatting rule for the tick exponents.',\n            'For example, consider the number 1,000,000,000.',\n            'If *none*, it appears as 1,000,000,000.',\n            'If *e*, 1e+9.',\n            'If *E*, 1E+9.',\n            'If *power*, 1x10^9 (with 9 in a super script).',\n            'If *SI*, 1G.',\n            'If *B*, 1B.'\n        ].join(' ')\n    },\n    minexponent: {\n        valType: 'number',\n        dflt: 3,\n        min: 0,\n        editType: 'ticks',\n        description: [\n            'Hide SI prefix for 10^n if |n| is below this number.',\n            'This only has an effect when `tickformat` is *SI* or *B*.'\n        ].join(' ')\n    },\n    separatethousands: {\n        valType: 'boolean',\n        dflt: false,\n        editType: 'ticks',\n        description: [\n            'If \"true\", even 4-digit integers are separated'\n        ].join(' ')\n    },\n    tickformat: {\n        valType: 'string',\n        dflt: '',\n        editType: 'ticks',\n        description: descriptionWithDates('tick label')\n    },\n    tickformatstops: templatedArray('tickformatstop', {\n        enabled: {\n            valType: 'boolean',\n            dflt: true,\n            editType: 'ticks',\n            description: [\n                'Determines whether or not this stop is used.',\n                'If `false`, this stop is ignored even within its `dtickrange`.'\n            ].join(' ')\n        },\n        dtickrange: {\n            valType: 'info_array',\n            items: [\n                {valType: 'any', editType: 'ticks'},\n                {valType: 'any', editType: 'ticks'}\n            ],\n            editType: 'ticks',\n            description: [\n                'range [*min*, *max*], where *min*, *max* - dtick values',\n                'which describe some zoom level, it is possible to omit *min*',\n                'or *max* value by passing *null*'\n            ].join(' ')\n        },\n        value: {\n            valType: 'string',\n            dflt: '',\n            editType: 'ticks',\n            description: [\n                'string - dtickformat for described zoom level, the same as *tickformat*'\n            ].join(' ')\n        },\n        editType: 'ticks'\n    }),\n    hoverformat: {\n        valType: 'string',\n        dflt: '',\n        editType: 'none',\n        description: descriptionWithDates('hover text')\n    },\n    // lines and grids\n    showline: {\n        valType: 'boolean',\n        dflt: false,\n        editType: 'ticks+layoutstyle',\n        description: [\n            'Determines whether or not a line bounding this axis is drawn.'\n        ].join(' ')\n    },\n    linecolor: {\n        valType: 'color',\n        dflt: colorAttrs.defaultLine,\n        editType: 'layoutstyle',\n        description: 'Sets the axis line color.'\n    },\n    linewidth: {\n        valType: 'number',\n        min: 0,\n        dflt: 1,\n        editType: 'ticks+layoutstyle',\n        description: 'Sets the width (in px) of the axis line.'\n    },\n    showgrid: showgrid,\n    gridcolor: gridcolor,\n    gridwidth: makeGridwidth(),\n    griddash: griddash,\n\n    zeroline: {\n        valType: 'boolean',\n        editType: 'ticks',\n        description: [\n            'Determines whether or not a line is drawn at along the 0 value',\n            'of this axis.',\n            'If *true*, the zero line is drawn on top of the grid lines.'\n        ].join(' ')\n    },\n    zerolinecolor: {\n        valType: 'color',\n        dflt: colorAttrs.defaultLine,\n        editType: 'ticks',\n        description: 'Sets the line color of the zero line.'\n    },\n    zerolinewidth: {\n        valType: 'number',\n        dflt: 1,\n        editType: 'ticks',\n        description: 'Sets the width (in px) of the zero line.'\n    },\n\n    showdividers: {\n        valType: 'boolean',\n        dflt: true,\n        editType: 'ticks',\n        description: [\n            'Determines whether or not a dividers are drawn',\n            'between the category levels of this axis.',\n            'Only has an effect on *multicategory* axes.'\n        ].join(' ')\n    },\n    dividercolor: {\n        valType: 'color',\n        dflt: colorAttrs.defaultLine,\n        editType: 'ticks',\n        description: [\n            'Sets the color of the dividers',\n            'Only has an effect on *multicategory* axes.'\n        ].join(' ')\n    },\n    dividerwidth: {\n        valType: 'number',\n        dflt: 1,\n        editType: 'ticks',\n        description: [\n            'Sets the width (in px) of the dividers',\n            'Only has an effect on *multicategory* axes.'\n        ].join(' ')\n    },\n    // TODO dividerlen: that would override \"to label base\" length?\n\n    // positioning attributes\n    // anchor: not used directly, just put here for reference\n    // values are any opposite-letter axis id\n    anchor: {\n        valType: 'enumerated',\n        values: [\n            'free',\n            constants.idRegex.x.toString(),\n            constants.idRegex.y.toString()\n        ],\n        editType: 'plot',\n        description: [\n            'If set to an opposite-letter axis id (e.g. `x2`, `y`), this axis is bound to',\n            'the corresponding opposite-letter axis.',\n            'If set to *free*, this axis\\' position is determined by `position`.'\n        ].join(' ')\n    },\n    // side: not used directly, as values depend on direction\n    // values are top, bottom for x axes, and left, right for y\n    side: {\n        valType: 'enumerated',\n        values: ['top', 'bottom', 'left', 'right'],\n        editType: 'plot',\n        description: [\n            'Determines whether a x (y) axis is positioned',\n            'at the *bottom* (*left*) or *top* (*right*)',\n            'of the plotting area.'\n        ].join(' ')\n    },\n    // overlaying: not used directly, just put here for reference\n    // values are false and any other same-letter axis id that's not\n    // itself overlaying anything\n    overlaying: {\n        valType: 'enumerated',\n        values: [\n            'free',\n            constants.idRegex.x.toString(),\n            constants.idRegex.y.toString()\n        ],\n        editType: 'plot',\n        description: [\n            'If set a same-letter axis id, this axis is overlaid on top of',\n            'the corresponding same-letter axis, with traces and axes visible for both',\n            'axes.',\n            'If *false*, this axis does not overlay any same-letter axes.',\n            'In this case, for axes with overlapping domains only the highest-numbered',\n            'axis will be visible.'\n        ].join(' ')\n    },\n\n    minor: {\n        tickmode: minorTickmode,\n        nticks: makeNticks('minor'),\n        tick0: tick0,\n        dtick: dtick,\n        tickvals: tickvals,\n        ticks: ticks,\n        ticklen: makeTicklen('minor'),\n        tickwidth: makeTickwidth('minor'),\n        tickcolor: tickcolor,\n\n        gridcolor: gridcolor,\n        gridwidth: makeGridwidth('minor'),\n        griddash: griddash,\n        showgrid: showgrid,\n\n        editType: 'ticks'\n    },\n\n    layer: {\n        valType: 'enumerated',\n        values: ['above traces', 'below traces'],\n        dflt: 'above traces',\n        editType: 'plot',\n        description: [\n            'Sets the layer on which this axis is displayed.',\n            'If *above traces*, this axis is displayed above all the subplot\\'s traces',\n            'If *below traces*, this axis is displayed below all the subplot\\'s traces,',\n            'but above the grid lines.',\n            'Useful when used together with scatter-like traces with `cliponaxis`',\n            'set to *false* to show markers and/or text nodes above this axis.'\n        ].join(' ')\n    },\n    domain: {\n        valType: 'info_array',\n        items: [\n            {valType: 'number', min: 0, max: 1, editType: 'plot'},\n            {valType: 'number', min: 0, max: 1, editType: 'plot'}\n        ],\n        dflt: [0, 1],\n        editType: 'plot',\n        description: [\n            'Sets the domain of this axis (in plot fraction).'\n        ].join(' ')\n    },\n    position: {\n        valType: 'number',\n        min: 0,\n        max: 1,\n        dflt: 0,\n        editType: 'plot',\n        description: [\n            'Sets the position of this axis in the plotting space',\n            '(in normalized coordinates).',\n            'Only has an effect if `anchor` is set to *free*.'\n        ].join(' ')\n    },\n    autoshift: {\n        valType: 'boolean',\n        dflt: false,\n        editType: 'plot',\n        description: [\n            'Automatically reposition the axis to avoid',\n            'overlap with other axes with the same `overlaying` value.',\n            'This repositioning will account for any `shift` amount applied to other',\n            'axes on the same side with `autoshift` is set to true.',\n            'Only has an effect if `anchor` is set to *free*.',\n        ].join(' ')\n    },\n    shift: {\n        valType: 'number',\n        editType: 'plot',\n        description: [\n            'Moves the axis a given number of pixels from where it would have been otherwise.',\n            'Accepts both positive and negative values, which will shift the axis either right',\n            'or left, respectively.',\n            'If `autoshift` is set to true, then this defaults to a padding of -3 if `side` is set to *left*.',\n            'and defaults to +3 if `side` is set to *right*. Defaults to 0 if `autoshift` is set to false.',\n            'Only has an effect if `anchor` is set to *free*.'\n        ].join(' ')\n    },\n    categoryorder: {\n        valType: 'enumerated',\n        values: [\n            'trace', 'category ascending', 'category descending', 'array',\n            'total ascending', 'total descending',\n            'min ascending', 'min descending',\n            'max ascending', 'max descending',\n            'sum ascending', 'sum descending',\n            'mean ascending', 'mean descending',\n            'median ascending', 'median descending'\n        ],\n        dflt: 'trace',\n        editType: 'calc',\n        description: [\n            'Specifies the ordering logic for the case of categorical variables.',\n            'By default, plotly uses *trace*, which specifies the order that is present in the data supplied.',\n            'Set `categoryorder` to *category ascending* or *category descending* if order should be determined by',\n            'the alphanumerical order of the category names.',\n            'Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category',\n            'is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to',\n            'the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.',\n            'Set `categoryorder` to *total ascending* or *total descending* if order should be determined by the',\n            'numerical order of the values.',\n            'Similarly, the order can be determined by the min, max, sum, mean or median of all the values.'\n        ].join(' ')\n    },\n    categoryarray: {\n        valType: 'data_array',\n        editType: 'calc',\n        description: [\n            'Sets the order in which categories on this axis appear.',\n            'Only has an effect if `categoryorder` is set to *array*.',\n            'Used with `categoryorder`.'\n        ].join(' ')\n    },\n    uirevision: {\n        valType: 'any',\n        editType: 'none',\n        description: [\n            'Controls persistence of user-driven changes in axis `range`,',\n            '`autorange`, and `title` if in `editable: true` configuration.',\n            'Defaults to `layout.uirevision`.'\n        ].join(' ')\n    },\n    editType: 'calc',\n\n    _deprecated: {\n        autotick: {\n            valType: 'boolean',\n            editType: 'ticks',\n            description: [\n                'Obsolete.',\n                'Set `tickmode` to *auto* for old `autotick` *true* behavior.',\n                'Set `tickmode` to *linear* for `autotick` *false*.'\n            ].join(' ')\n        },\n        title: {\n            valType: 'string',\n            editType: 'ticks',\n            description: [\n                'Value of `title` is no longer a simple *string* but a set of sub-attributes.',\n                'To set the axis\\' title, please use `title.text` now.'\n            ].join(' ')\n        },\n        titlefont: fontAttrs({\n            editType: 'ticks',\n            description: [\n                'Former `titlefont` is now the sub-attribute `font` of `title`.',\n                'To customize title font properties, please use `title.font` now.'\n            ].join(' ')\n        })\n    }\n};\n","'use strict';\n\nvar Lib = require('../../lib');\nvar Color = require('../../components/color');\nvar isUnifiedHover = require('../../components/fx/helpers').isUnifiedHover;\nvar handleHoverModeDefaults = require('../../components/fx/hovermode_defaults');\nvar Template = require('../../plot_api/plot_template');\nvar basePlotLayoutAttributes = require('../layout_attributes');\n\nvar layoutAttributes = require('./layout_attributes');\nvar handleTypeDefaults = require('./type_defaults');\nvar handleAxisDefaults = require('./axis_defaults');\nvar constraints = require('./constraints');\nvar handlePositionDefaults = require('./position_defaults');\n\nvar axisIds = require('./axis_ids');\nvar id2name = axisIds.id2name;\nvar name2id = axisIds.name2id;\n\nvar AX_ID_PATTERN = require('./constants').AX_ID_PATTERN;\n\nvar Registry = require('../../registry');\nvar traceIs = Registry.traceIs;\nvar getComponentMethod = Registry.getComponentMethod;\n\nfunction appendList(cont, k, item) {\n    if(Array.isArray(cont[k])) cont[k].push(item);\n    else cont[k] = [item];\n}\n\nmodule.exports = function supplyLayoutDefaults(layoutIn, layoutOut, fullData) {\n    var autotypenumbersDflt = layoutOut.autotypenumbers;\n\n    var ax2traces = {};\n    var xaMayHide = {};\n    var yaMayHide = {};\n    var xaMustDisplay = {};\n    var yaMustDisplay = {};\n    var yaMustNotReverse = {};\n    var yaMayReverse = {};\n    var axHasImage = {};\n    var outerTicks = {};\n    var noGrids = {};\n    var i, j;\n\n    // look for axes in the data\n    for(i = 0; i < fullData.length; i++) {\n        var trace = fullData[i];\n        if(!traceIs(trace, 'cartesian') && !traceIs(trace, 'gl2d')) continue;\n\n        var xaName;\n        if(trace.xaxis) {\n            xaName = id2name(trace.xaxis);\n            appendList(ax2traces, xaName, trace);\n        } else if(trace.xaxes) {\n            for(j = 0; j < trace.xaxes.length; j++) {\n                appendList(ax2traces, id2name(trace.xaxes[j]), trace);\n            }\n        }\n\n        var yaName;\n        if(trace.yaxis) {\n            yaName = id2name(trace.yaxis);\n            appendList(ax2traces, yaName, trace);\n        } else if(trace.yaxes) {\n            for(j = 0; j < trace.yaxes.length; j++) {\n                appendList(ax2traces, id2name(trace.yaxes[j]), trace);\n            }\n        }\n\n        // logic for funnels\n        if(trace.type === 'funnel') {\n            if(trace.orientation === 'h') {\n                if(xaName) xaMayHide[xaName] = true;\n                if(yaName) yaMayReverse[yaName] = true;\n            } else {\n                if(yaName) yaMayHide[yaName] = true;\n            }\n        } else if(trace.type === 'image') {\n            if(yaName) axHasImage[yaName] = true;\n            if(xaName) axHasImage[xaName] = true;\n        } else {\n            if(yaName) {\n                yaMustDisplay[yaName] = true;\n                yaMustNotReverse[yaName] = true;\n            }\n\n            if(!traceIs(trace, 'carpet') || (trace.type === 'carpet' && !trace._cheater)) {\n                if(xaName) xaMustDisplay[xaName] = true;\n            }\n        }\n\n        // Two things trigger axis visibility:\n        // 1. is not carpet\n        // 2. carpet that's not cheater\n\n        // The above check for definitely-not-cheater is not adequate. This\n        // second list tracks which axes *could* be a cheater so that the\n        // full condition triggering hiding is:\n        //   *could* be a cheater and *is not definitely visible*\n        if(trace.type === 'carpet' && trace._cheater) {\n            if(xaName) xaMayHide[xaName] = true;\n        }\n\n        // check for default formatting tweaks\n        if(traceIs(trace, '2dMap')) {\n            outerTicks[xaName] = true;\n            outerTicks[yaName] = true;\n        }\n\n        if(traceIs(trace, 'oriented')) {\n            var positionAxis = trace.orientation === 'h' ? yaName : xaName;\n            noGrids[positionAxis] = true;\n        }\n    }\n\n    var subplots = layoutOut._subplots;\n    var xIds = subplots.xaxis;\n    var yIds = subplots.yaxis;\n    var xNames = Lib.simpleMap(xIds, id2name);\n    var yNames = Lib.simpleMap(yIds, id2name);\n    var axNames = xNames.concat(yNames);\n\n    // plot_bgcolor only makes sense if there's a (2D) plot!\n    // TODO: bgcolor for each subplot, to inherit from the main one\n    var plotBgColor = Color.background;\n    if(xIds.length && yIds.length) {\n        plotBgColor = Lib.coerce(layoutIn, layoutOut, basePlotLayoutAttributes, 'plot_bgcolor');\n    }\n\n    var bgColor = Color.combine(plotBgColor, layoutOut.paper_bgcolor);\n\n    // name of single axis (e.g. 'xaxis', 'yaxis2')\n    var axName;\n    // id of single axis (e.g. 'y', 'x5')\n    var axId;\n    // 'x' or 'y'\n    var axLetter;\n    // input layout axis container\n    var axLayoutIn;\n    // full layout axis container\n    var axLayoutOut;\n\n    function newAxLayoutOut() {\n        var traces = ax2traces[axName] || [];\n        axLayoutOut._traceIndices = traces.map(function(t) { return t._expandedIndex; });\n        axLayoutOut._annIndices = [];\n        axLayoutOut._shapeIndices = [];\n        axLayoutOut._selectionIndices = [];\n        axLayoutOut._imgIndices = [];\n        axLayoutOut._subplotsWith = [];\n        axLayoutOut._counterAxes = [];\n        axLayoutOut._name = axLayoutOut._attr = axName;\n        axLayoutOut._id = axId;\n    }\n\n    function coerce(attr, dflt) {\n        return Lib.coerce(axLayoutIn, axLayoutOut, layoutAttributes, attr, dflt);\n    }\n\n    function coerce2(attr, dflt) {\n        return Lib.coerce2(axLayoutIn, axLayoutOut, layoutAttributes, attr, dflt);\n    }\n\n    function getCounterAxes(axLetter) {\n        return (axLetter === 'x') ? yIds : xIds;\n    }\n\n    function getOverlayableAxes(axLetter, axName) {\n        var list = (axLetter === 'x') ? xNames : yNames;\n        var out = [];\n\n        for(var j = 0; j < list.length; j++) {\n            var axName2 = list[j];\n\n            if(axName2 !== axName && !(layoutIn[axName2] || {}).overlaying) {\n                out.push(name2id(axName2));\n            }\n        }\n\n        return out;\n    }\n\n    // list of available counter axis names\n    var counterAxes = {x: getCounterAxes('x'), y: getCounterAxes('y')};\n    // list of all x AND y axis ids\n    var allAxisIds = counterAxes.x.concat(counterAxes.y);\n    // lookup and list of axis ids that axes in axNames have a reference to,\n    // even though they are missing from allAxisIds\n    var missingMatchedAxisIdsLookup = {};\n    var missingMatchedAxisIds = [];\n\n    // fill in 'missing' axis lookup when an axis is set to match an axis\n    // not part of the allAxisIds list, save axis type so that we can propagate\n    // it to the missing axes\n    function addMissingMatchedAxis() {\n        var matchesIn = axLayoutIn.matches;\n        if(AX_ID_PATTERN.test(matchesIn) && allAxisIds.indexOf(matchesIn) === -1) {\n            missingMatchedAxisIdsLookup[matchesIn] = axLayoutIn.type;\n            missingMatchedAxisIds = Object.keys(missingMatchedAxisIdsLookup);\n        }\n    }\n\n    var hovermode = handleHoverModeDefaults(layoutIn, layoutOut);\n    var unifiedHover = isUnifiedHover(hovermode);\n\n    // first pass creates the containers, determines types, and handles most of the settings\n    for(i = 0; i < axNames.length; i++) {\n        axName = axNames[i];\n        axId = name2id(axName);\n        axLetter = axName.charAt(0);\n\n        if(!Lib.isPlainObject(layoutIn[axName])) {\n            layoutIn[axName] = {};\n        }\n\n        axLayoutIn = layoutIn[axName];\n        axLayoutOut = Template.newContainer(layoutOut, axName, axLetter + 'axis');\n        newAxLayoutOut();\n\n        var visibleDflt =\n            (axLetter === 'x' && !xaMustDisplay[axName] && xaMayHide[axName]) ||\n            (axLetter === 'y' && !yaMustDisplay[axName] && yaMayHide[axName]);\n\n        var reverseDflt =\n            (axLetter === 'y' &&\n              (\n                (!yaMustNotReverse[axName] && yaMayReverse[axName]) ||\n                axHasImage[axName]\n              ));\n\n        var defaultOptions = {\n            hasMinor: true,\n            letter: axLetter,\n            font: layoutOut.font,\n            outerTicks: outerTicks[axName],\n            showGrid: !noGrids[axName],\n            data: ax2traces[axName] || [],\n            bgColor: bgColor,\n            calendar: layoutOut.calendar,\n            automargin: true,\n            visibleDflt: visibleDflt,\n            reverseDflt: reverseDflt,\n            autotypenumbersDflt: autotypenumbersDflt,\n            splomStash: ((layoutOut._splomAxes || {})[axLetter] || {})[axId],\n            noAutotickangles: axLetter === 'y'\n        };\n\n        coerce('uirevision', layoutOut.uirevision);\n\n        handleTypeDefaults(axLayoutIn, axLayoutOut, coerce, defaultOptions);\n        handleAxisDefaults(axLayoutIn, axLayoutOut, coerce, defaultOptions, layoutOut);\n\n        var unifiedSpike = unifiedHover && axLetter === hovermode.charAt(0);\n        var spikecolor = coerce2('spikecolor', unifiedHover ? axLayoutOut.color : undefined);\n        var spikethickness = coerce2('spikethickness', unifiedHover ? 1.5 : undefined);\n        var spikedash = coerce2('spikedash', unifiedHover ? 'dot' : undefined);\n        var spikemode = coerce2('spikemode', unifiedHover ? 'across' : undefined);\n        var spikesnap = coerce2('spikesnap');\n        var showSpikes = coerce('showspikes', !!unifiedSpike || !!spikecolor || !!spikethickness || !!spikedash || !!spikemode || !!spikesnap);\n\n        if(!showSpikes) {\n            delete axLayoutOut.spikecolor;\n            delete axLayoutOut.spikethickness;\n            delete axLayoutOut.spikedash;\n            delete axLayoutOut.spikemode;\n            delete axLayoutOut.spikesnap;\n        }\n\n        // If it exists, the the domain of the axis for the anchor of the overlaying axis\n        var overlayingAxis = id2name(axLayoutIn.overlaying);\n        var overlayingAnchorDomain = [0, 1];\n\n        if(layoutOut[overlayingAxis] !== undefined) {\n            var overlayingAnchor = id2name(layoutOut[overlayingAxis].anchor);\n            if(layoutOut[overlayingAnchor] !== undefined) {\n                overlayingAnchorDomain = layoutOut[overlayingAnchor].domain;\n            }\n        }\n\n        handlePositionDefaults(axLayoutIn, axLayoutOut, coerce, {\n            letter: axLetter,\n            counterAxes: counterAxes[axLetter],\n            overlayableAxes: getOverlayableAxes(axLetter, axName),\n            grid: layoutOut.grid,\n            overlayingDomain: overlayingAnchorDomain\n\n        });\n\n        coerce('title.standoff');\n\n        addMissingMatchedAxis();\n\n        axLayoutOut._input = axLayoutIn;\n    }\n\n    // coerce the 'missing' axes\n    i = 0;\n    while(i < missingMatchedAxisIds.length) {\n        axId = missingMatchedAxisIds[i++];\n        axName = id2name(axId);\n        axLetter = axName.charAt(0);\n\n        if(!Lib.isPlainObject(layoutIn[axName])) {\n            layoutIn[axName] = {};\n        }\n\n        axLayoutIn = layoutIn[axName];\n        axLayoutOut = Template.newContainer(layoutOut, axName, axLetter + 'axis');\n        newAxLayoutOut();\n\n        var defaultOptions2 = {\n            letter: axLetter,\n            font: layoutOut.font,\n            outerTicks: outerTicks[axName],\n            showGrid: !noGrids[axName],\n            data: [],\n            bgColor: bgColor,\n            calendar: layoutOut.calendar,\n            automargin: true,\n            visibleDflt: false,\n            reverseDflt: false,\n            autotypenumbersDflt: autotypenumbersDflt,\n            splomStash: ((layoutOut._splomAxes || {})[axLetter] || {})[axId]\n        };\n\n        coerce('uirevision', layoutOut.uirevision);\n\n        axLayoutOut.type = missingMatchedAxisIdsLookup[axId] || 'linear';\n\n        handleAxisDefaults(axLayoutIn, axLayoutOut, coerce, defaultOptions2, layoutOut);\n\n        handlePositionDefaults(axLayoutIn, axLayoutOut, coerce, {\n            letter: axLetter,\n            counterAxes: counterAxes[axLetter],\n            overlayableAxes: getOverlayableAxes(axLetter, axName),\n            grid: layoutOut.grid\n        });\n\n        coerce('fixedrange');\n\n        addMissingMatchedAxis();\n\n        axLayoutOut._input = axLayoutIn;\n    }\n\n    // quick second pass for range slider and selector defaults\n    var rangeSliderDefaults = getComponentMethod('rangeslider', 'handleDefaults');\n    var rangeSelectorDefaults = getComponentMethod('rangeselector', 'handleDefaults');\n\n    for(i = 0; i < xNames.length; i++) {\n        axName = xNames[i];\n        axLayoutIn = layoutIn[axName];\n        axLayoutOut = layoutOut[axName];\n\n        rangeSliderDefaults(layoutIn, layoutOut, axName);\n\n        if(axLayoutOut.type === 'date') {\n            rangeSelectorDefaults(\n                axLayoutIn,\n                axLayoutOut,\n                layoutOut,\n                yNames,\n                axLayoutOut.calendar\n            );\n        }\n\n        coerce('fixedrange');\n    }\n\n    for(i = 0; i < yNames.length; i++) {\n        axName = yNames[i];\n        axLayoutIn = layoutIn[axName];\n        axLayoutOut = layoutOut[axName];\n\n        var anchoredAxis = layoutOut[id2name(axLayoutOut.anchor)];\n\n        var fixedRangeDflt = getComponentMethod('rangeslider', 'isVisible')(anchoredAxis);\n\n        coerce('fixedrange', fixedRangeDflt);\n    }\n\n    // Finally, handle scale constraints and matching axes.\n    //\n    // We need to do this after all axes have coerced both `type`\n    // (so we link only axes of the same type) and\n    // `fixedrange` (so we can avoid linking from OR TO a fixed axis).\n    constraints.handleDefaults(layoutIn, layoutOut, {\n        axIds: allAxisIds.concat(missingMatchedAxisIds).sort(axisIds.idSort),\n        axHasImage: axHasImage\n    });\n};\n","'use strict';\n\nvar colorMix = require('tinycolor2').mix;\nvar colorAttrs = require('../../components/color/attributes');\nvar Lib = require('../../lib');\n\n/**\n * @param {object} opts :\n *   - dfltColor {string} : default axis color\n *   - bgColor {string} : combined subplot bg color\n *   - blend {number, optional} : blend percentage (to compute dflt grid color)\n *   - showLine {boolean} : show line by default\n *   - showGrid {boolean} : show grid by default\n *   - noZeroLine {boolean} : don't coerce zeroline* attributes\n *   - attributes {object} : attribute object associated with input containers\n */\nmodule.exports = function handleLineGridDefaults(containerIn, containerOut, coerce, opts) {\n    opts = opts || {};\n\n    var dfltColor = opts.dfltColor;\n\n    function coerce2(attr, dflt) {\n        return Lib.coerce2(containerIn, containerOut, opts.attributes, attr, dflt);\n    }\n\n    var lineColor = coerce2('linecolor', dfltColor);\n    var lineWidth = coerce2('linewidth');\n    var showLine = coerce('showline', opts.showLine || !!lineColor || !!lineWidth);\n\n    if(!showLine) {\n        delete containerOut.linecolor;\n        delete containerOut.linewidth;\n    }\n\n    var gridColorDflt = colorMix(dfltColor, opts.bgColor, opts.blend || colorAttrs.lightFraction).toRgbString();\n    var gridColor = coerce2('gridcolor', gridColorDflt);\n    var gridWidth = coerce2('gridwidth');\n    var gridDash = coerce2('griddash');\n    var showGridLines = coerce('showgrid', opts.showGrid ||\n        !!gridColor ||\n        !!gridWidth ||\n        !!gridDash\n    );\n\n    if(!showGridLines) {\n        delete containerOut.gridcolor;\n        delete containerOut.gridwidth;\n        delete containerOut.griddash;\n    }\n\n    if(opts.hasMinor) {\n        var minorGridColorDflt = colorMix(containerOut.gridcolor, opts.bgColor, 67).toRgbString();\n        var minorGridColor = coerce2('minor.gridcolor', minorGridColorDflt);\n        var minorGridWidth = coerce2('minor.gridwidth', containerOut.gridwidth || 1);\n        var minorGridDash = coerce2('minor.griddash', containerOut.griddash || 'solid');\n        var minorShowGridLines = coerce('minor.showgrid',\n            !!minorGridColor ||\n            !!minorGridWidth ||\n            !!minorGridDash\n        );\n\n        if(!minorShowGridLines) {\n            delete containerOut.minor.gridcolor;\n            delete containerOut.minor.gridwidth;\n            delete containerOut.minor.griddash;\n        }\n    }\n\n    if(!opts.noZeroLine) {\n        var zeroLineColor = coerce2('zerolinecolor', dfltColor);\n        var zeroLineWidth = coerce2('zerolinewidth');\n        var showZeroLine = coerce('zeroline', opts.showGrid || !!zeroLineColor || !!zeroLineWidth);\n\n        if(!showZeroLine) {\n            delete containerOut.zerolinecolor;\n            delete containerOut.zerolinewidth;\n        }\n    }\n};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\n\nvar Lib = require('../../lib');\n\n\nmodule.exports = function handlePositionDefaults(containerIn, containerOut, coerce, options) {\n    var counterAxes = options.counterAxes || [];\n    var overlayableAxes = options.overlayableAxes || [];\n    var letter = options.letter;\n    var grid = options.grid;\n    var overlayingDomain = options.overlayingDomain;\n    var dfltAnchor, dfltDomain, dfltSide, dfltPosition, dfltShift, dfltAutomargin;\n\n    if(grid) {\n        dfltDomain = grid._domains[letter][grid._axisMap[containerOut._id]];\n        dfltAnchor = grid._anchors[containerOut._id];\n        if(dfltDomain) {\n            dfltSide = grid[letter + 'side'].split(' ')[0];\n            dfltPosition = grid.domain[letter][dfltSide === 'right' || dfltSide === 'top' ? 1 : 0];\n        }\n    }\n\n    // Even if there's a grid, this axis may not be in it - fall back on non-grid defaults\n    dfltDomain = dfltDomain || [0, 1];\n    dfltAnchor = dfltAnchor || (isNumeric(containerIn.position) ? 'free' : (counterAxes[0] || 'free'));\n    dfltSide = dfltSide || (letter === 'x' ? 'bottom' : 'left');\n    dfltPosition = dfltPosition || 0;\n    dfltShift = 0;\n    dfltAutomargin = false;\n\n    var anchor = Lib.coerce(containerIn, containerOut, {\n        anchor: {\n            valType: 'enumerated',\n            values: ['free'].concat(counterAxes),\n            dflt: dfltAnchor\n        }\n    }, 'anchor');\n\n    var side = Lib.coerce(containerIn, containerOut, {\n        side: {\n            valType: 'enumerated',\n            values: letter === 'x' ? ['bottom', 'top'] : ['left', 'right'],\n            dflt: dfltSide\n        }\n    }, 'side');\n\n    if(anchor === 'free') {\n        if(letter === 'y') {\n            var autoshift = coerce('autoshift');\n            if(autoshift) {\n                dfltPosition = side === 'left' ? overlayingDomain[0] : overlayingDomain[1];\n                dfltAutomargin = containerOut.automargin ? containerOut.automargin : true;\n                dfltShift = side === 'left' ? -3 : 3;\n            }\n            coerce('shift', dfltShift);\n        }\n        coerce('position', dfltPosition);\n    }\n    coerce('automargin', dfltAutomargin);\n\n    var overlaying = false;\n    if(overlayableAxes.length) {\n        overlaying = Lib.coerce(containerIn, containerOut, {\n            overlaying: {\n                valType: 'enumerated',\n                values: [false].concat(overlayableAxes),\n                dflt: false\n            }\n        }, 'overlaying');\n    }\n\n    if(!overlaying) {\n        // TODO: right now I'm copying this domain over to overlaying axes\n        // in ax.setscale()... but this means we still need (imperfect) logic\n        // in the axes popover to hide domain for the overlaying axis.\n        // perhaps I should make a private version _domain that all axes get???\n        var domain = coerce('domain', dfltDomain);\n\n        // according to https://www.npmjs.com/package/canvas-size\n        // the minimum value of max canvas width across browsers and devices is 4096\n        // which applied in the calculation below:\n        if(domain[0] > domain[1] - 1 / 4096) containerOut.domain = dfltDomain;\n        Lib.noneOrAll(containerIn.domain, containerOut.domain, dfltDomain);\n\n        // tickmode sync needs an overlaying axis, otherwise\n        // we should default it to 'auto'\n        if(containerOut.tickmode === 'sync') {\n            containerOut.tickmode = 'auto';\n        }\n    }\n\n    coerce('layer');\n\n    return containerOut;\n};\n","'use strict';\n\nvar getShowAttrDflt = require('./show_dflt');\n\nmodule.exports = function handlePrefixSuffixDefaults(containerIn, containerOut, coerce, axType, options) {\n    if(!options) options = {};\n    var tickSuffixDflt = options.tickSuffixDflt;\n\n    var showAttrDflt = getShowAttrDflt(containerIn);\n\n    var tickPrefix = coerce('tickprefix');\n    if(tickPrefix) coerce('showtickprefix', showAttrDflt);\n\n    var tickSuffix = coerce('ticksuffix', tickSuffixDflt);\n    if(tickSuffix) coerce('showticksuffix', showAttrDflt);\n};\n","'use strict';\n\nvar handleAutorangeOptionsDefaults = require('./autorange_options_defaults');\n\nmodule.exports = function handleRangeDefaults(containerIn, containerOut, coerce, options) {\n    var axTemplate = containerOut._template || {};\n    var axType = containerOut.type || axTemplate.type || '-';\n\n    coerce('minallowed');\n    coerce('maxallowed');\n\n    var range = coerce('range');\n    if(!range) {\n        var insiderange;\n        if(!options.noInsiderange && axType !== 'log') {\n            insiderange = coerce('insiderange');\n\n            // We may support partial insideranges in future\n            // For now it is out of scope\n            if(insiderange && (\n                    insiderange[0] === null ||\n                    insiderange[1] === null\n            )) {\n                containerOut.insiderange = false;\n                insiderange = undefined;\n            }\n\n            if(insiderange) range = coerce('range', insiderange);\n        }\n    }\n\n    var autorangeDflt = containerOut.getAutorangeDflt(range, options);\n    var autorange = coerce('autorange', autorangeDflt);\n\n    var shouldAutorange;\n\n    // validate range and set autorange true for invalid partial ranges\n    if(range && (\n        (range[0] === null && range[1] === null) ||\n        ((range[0] === null || range[1] === null) && (autorange === 'reversed' || autorange === true)) ||\n        (range[0] !== null && (autorange === 'min' || autorange === 'max reversed')) ||\n        (range[1] !== null && (autorange === 'max' || autorange === 'min reversed'))\n    )) {\n        range = undefined;\n        delete containerOut.range;\n        containerOut.autorange = true;\n        shouldAutorange = true;\n    }\n\n    if(!shouldAutorange) {\n        autorangeDflt = containerOut.getAutorangeDflt(range, options);\n        autorange = coerce('autorange', autorangeDflt);\n    }\n\n    if(autorange) {\n        handleAutorangeOptionsDefaults(coerce, autorange, range);\n        if(axType === 'linear' || axType === '-') coerce('rangemode');\n    }\n\n    containerOut.cleanRange();\n};\n","'use strict';\n\nvar FROM_BL = require('../../constants/alignment').FROM_BL;\n\nmodule.exports = function scaleZoom(ax, factor, centerFraction) {\n    if(centerFraction === undefined) {\n        centerFraction = FROM_BL[ax.constraintoward || 'center'];\n    }\n\n    var rangeLinear = [ax.r2l(ax.range[0]), ax.r2l(ax.range[1])];\n    var center = rangeLinear[0] + (rangeLinear[1] - rangeLinear[0]) * centerFraction;\n\n    ax.range = ax._input.range = [\n        ax.l2r(center + (rangeLinear[0] - center) * factor),\n        ax.l2r(center + (rangeLinear[1] - center) * factor)\n    ];\n    ax.setScale();\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar utcFormat = require('d3-time-format').utcFormat;\nvar Lib = require('../../lib');\nvar numberFormat = Lib.numberFormat;\nvar isNumeric = require('fast-isnumeric');\n\nvar cleanNumber = Lib.cleanNumber;\nvar ms2DateTime = Lib.ms2DateTime;\nvar dateTime2ms = Lib.dateTime2ms;\nvar ensureNumber = Lib.ensureNumber;\nvar isArrayOrTypedArray = Lib.isArrayOrTypedArray;\n\nvar numConstants = require('../../constants/numerical');\nvar FP_SAFE = numConstants.FP_SAFE;\nvar BADNUM = numConstants.BADNUM;\nvar LOG_CLIP = numConstants.LOG_CLIP;\nvar ONEWEEK = numConstants.ONEWEEK;\nvar ONEDAY = numConstants.ONEDAY;\nvar ONEHOUR = numConstants.ONEHOUR;\nvar ONEMIN = numConstants.ONEMIN;\nvar ONESEC = numConstants.ONESEC;\n\nvar axisIds = require('./axis_ids');\nvar constants = require('./constants');\nvar HOUR_PATTERN = constants.HOUR_PATTERN;\nvar WEEKDAY_PATTERN = constants.WEEKDAY_PATTERN;\n\nfunction fromLog(v) {\n    return Math.pow(10, v);\n}\n\nfunction isValidCategory(v) {\n    return v !== null && v !== undefined;\n}\n\n/**\n * Define the conversion functions for an axis data is used in 5 ways:\n *\n *  d: data, in whatever form it's provided\n *  c: calcdata: turned into numbers, but not linearized\n *  l: linearized - same as c except for log axes (and other nonlinear\n *      mappings later?) this is used when we need to know if it's\n *      *possible* to show some data on this axis, without caring about\n *      the current range\n *  p: pixel value - mapped to the screen with current size and zoom\n *  r: ranges, tick0, and annotation positions match one of the above\n *     but are handled differently for different types:\n *     - linear and date: data format (d)\n *     - category: calcdata format (c), and will stay that way because\n *       the data format has no continuous mapping\n *     - log: linearized (l) format\n *       TODO: in v3.0 we plan to change it to data format. At that point\n *       shapes will work the same way as ranges, tick0, and annotations\n *       so they can use this conversion too.\n *\n * Creates/updates these conversion functions, and a few more utilities\n * like cleanRange, and makeCalcdata\n *\n * also clears the autotick constraints ._minDtick, ._forceTick0\n */\nmodule.exports = function setConvert(ax, fullLayout) {\n    fullLayout = fullLayout || {};\n\n    var axId = (ax._id || 'x');\n    var axLetter = axId.charAt(0);\n\n    function toLog(v, clip) {\n        if(v > 0) return Math.log(v) / Math.LN10;\n\n        else if(v <= 0 && clip && ax.range && ax.range.length === 2) {\n            // clip NaN (ie past negative infinity) to LOG_CLIP axis\n            // length past the negative edge\n            var r0 = ax.range[0];\n            var r1 = ax.range[1];\n            return 0.5 * (r0 + r1 - 2 * LOG_CLIP * Math.abs(r0 - r1));\n        } else return BADNUM;\n    }\n\n    /*\n     * wrapped dateTime2ms that:\n     * - accepts ms numbers for backward compatibility\n     * - inserts a dummy arg so calendar is the 3rd arg (see notes below).\n     * - defaults to ax.calendar\n     */\n    function dt2ms(v, _, calendar, opts) {\n        if((opts || {}).msUTC && isNumeric(v)) {\n            // For now it is only used\n            // to fix bar length in milliseconds & gl3d ticks\n            // It could be applied in other places in v3\n            return +v;\n        }\n\n        // NOTE: Changed this behavior: previously we took any numeric value\n        // to be a ms, even if it was a string that could be a bare year.\n        // Now we convert it as a date if at all possible, and only try\n        // as (local) ms if that fails.\n        var ms = dateTime2ms(v, calendar || ax.calendar);\n        if(ms === BADNUM) {\n            if(isNumeric(v)) {\n                v = +v;\n                // keep track of tenths of ms, that `new Date` will drop\n                // same logic as in Lib.ms2DateTime\n                var msecTenths = Math.floor(Lib.mod(v + 0.05, 1) * 10);\n                var msRounded = Math.round(v - msecTenths / 10);\n                ms = dateTime2ms(new Date(msRounded)) + msecTenths / 10;\n            } else return BADNUM;\n        }\n        return ms;\n    }\n\n    // wrapped ms2DateTime to insert default ax.calendar\n    function ms2dt(v, r, calendar) {\n        return ms2DateTime(v, r, calendar || ax.calendar);\n    }\n\n    function getCategoryName(v) {\n        return ax._categories[Math.round(v)];\n    }\n\n    /*\n     * setCategoryIndex: return the index of category v,\n     * inserting it in the list if it's not already there\n     *\n     * this will enter the categories in the order it\n     * encounters them, ie all the categories from the\n     * first data set, then all the ones from the second\n     * that aren't in the first etc.\n     *\n     * it is assumed that this function is being invoked in the\n     * already sorted category order; otherwise there would be\n     * a disconnect between the array and the index returned\n     */\n    function setCategoryIndex(v) {\n        if(isValidCategory(v)) {\n            if(ax._categoriesMap === undefined) {\n                ax._categoriesMap = {};\n            }\n\n            if(ax._categoriesMap[v] !== undefined) {\n                return ax._categoriesMap[v];\n            } else {\n                ax._categories.push(typeof v === 'number' ? String(v) : v);\n\n                var curLength = ax._categories.length - 1;\n                ax._categoriesMap[v] = curLength;\n\n                return curLength;\n            }\n        }\n        return BADNUM;\n    }\n\n    function setMultiCategoryIndex(arrayIn, len) {\n        var arrayOut = new Array(len);\n\n        for(var i = 0; i < len; i++) {\n            var v0 = (arrayIn[0] || [])[i];\n            var v1 = (arrayIn[1] || [])[i];\n            arrayOut[i] = getCategoryIndex([v0, v1]);\n        }\n\n        return arrayOut;\n    }\n\n    function getCategoryIndex(v) {\n        if(ax._categoriesMap) {\n            return ax._categoriesMap[v];\n        }\n    }\n\n    function getCategoryPosition(v) {\n        // d2l/d2c variant that that won't add categories but will also\n        // allow numbers to be mapped to the linearized axis positions\n        var index = getCategoryIndex(v);\n        if(index !== undefined) return index;\n        if(isNumeric(v)) return +v;\n    }\n\n    function getRangePosition(v) {\n        return isNumeric(v) ? +v : getCategoryIndex(v);\n    }\n\n    // include 2 fractional digits on pixel, for PDF zooming etc\n    function _l2p(v, m, b) { return d3.round(b + m * v, 2); }\n\n    function _p2l(px, m, b) { return (px - b) / m; }\n\n    var l2p = function l2p(v) {\n        if(!isNumeric(v)) return BADNUM;\n        return _l2p(v, ax._m, ax._b);\n    };\n\n    var p2l = function(px) {\n        return _p2l(px, ax._m, ax._b);\n    };\n\n    if(ax.rangebreaks) {\n        var isY = axLetter === 'y';\n\n        l2p = function(v) {\n            if(!isNumeric(v)) return BADNUM;\n            var len = ax._rangebreaks.length;\n            if(!len) return _l2p(v, ax._m, ax._b);\n\n            var flip = isY;\n            if(ax.range[0] > ax.range[1]) flip = !flip;\n            var signAx = flip ? -1 : 1;\n            var pos = signAx * v;\n\n            var q = 0;\n            for(var i = 0; i < len; i++) {\n                var min = signAx * ax._rangebreaks[i].min;\n                var max = signAx * ax._rangebreaks[i].max;\n\n                if(pos < min) break;\n                if(pos > max) q = i + 1;\n                else {\n                    // when falls into break, pick 'closest' offset\n                    q = pos < (min + max) / 2 ? i : i + 1;\n                    break;\n                }\n            }\n            var b2 = ax._B[q] || 0;\n            if(!isFinite(b2)) return 0; // avoid NaN translate e.g. in positionLabels if one keep zooming exactly into a break\n            return _l2p(v, ax._m2, b2);\n        };\n\n        p2l = function(px) {\n            var len = ax._rangebreaks.length;\n            if(!len) return _p2l(px, ax._m, ax._b);\n\n            var q = 0;\n            for(var i = 0; i < len; i++) {\n                if(px < ax._rangebreaks[i].pmin) break;\n                if(px > ax._rangebreaks[i].pmax) q = i + 1;\n            }\n            return _p2l(px, ax._m2, ax._B[q]);\n        };\n    }\n\n    // conversions among c/l/p are fairly simple - do them together for all axis types\n    ax.c2l = (ax.type === 'log') ? toLog : ensureNumber;\n    ax.l2c = (ax.type === 'log') ? fromLog : ensureNumber;\n\n    ax.l2p = l2p;\n    ax.p2l = p2l;\n\n    ax.c2p = (ax.type === 'log') ? function(v, clip) { return l2p(toLog(v, clip)); } : l2p;\n    ax.p2c = (ax.type === 'log') ? function(px) { return fromLog(p2l(px)); } : p2l;\n\n    /*\n     * now type-specific conversions for **ALL** other combinations\n     * they're all written out, instead of being combinations of each other, for\n     * both clarity and speed.\n     */\n    if(['linear', '-'].indexOf(ax.type) !== -1) {\n        // all are data vals, but d and r need cleaning\n        ax.d2r = ax.r2d = ax.d2c = ax.r2c = ax.d2l = ax.r2l = cleanNumber;\n        ax.c2d = ax.c2r = ax.l2d = ax.l2r = ensureNumber;\n\n        ax.d2p = ax.r2p = function(v) { return ax.l2p(cleanNumber(v)); };\n        ax.p2d = ax.p2r = p2l;\n\n        ax.cleanPos = ensureNumber;\n    } else if(ax.type === 'log') {\n        // d and c are data vals, r and l are logged (but d and r need cleaning)\n        ax.d2r = ax.d2l = function(v, clip) { return toLog(cleanNumber(v), clip); };\n        ax.r2d = ax.r2c = function(v) { return fromLog(cleanNumber(v)); };\n\n        ax.d2c = ax.r2l = cleanNumber;\n        ax.c2d = ax.l2r = ensureNumber;\n\n        ax.c2r = toLog;\n        ax.l2d = fromLog;\n\n        ax.d2p = function(v, clip) { return ax.l2p(ax.d2r(v, clip)); };\n        ax.p2d = function(px) { return fromLog(p2l(px)); };\n\n        ax.r2p = function(v) { return ax.l2p(cleanNumber(v)); };\n        ax.p2r = p2l;\n\n        ax.cleanPos = ensureNumber;\n    } else if(ax.type === 'date') {\n        // r and d are date strings, l and c are ms\n\n        /*\n         * Any of these functions with r and d on either side, calendar is the\n         * **3rd** argument. log has reserved the second argument.\n         *\n         * Unless you need the special behavior of the second arg (ms2DateTime\n         * uses this to limit precision, toLog uses true to clip negatives\n         * to offscreen low rather than undefined), it's safe to pass 0.\n         */\n        ax.d2r = ax.r2d = Lib.identity;\n\n        ax.d2c = ax.r2c = ax.d2l = ax.r2l = dt2ms;\n        ax.c2d = ax.c2r = ax.l2d = ax.l2r = ms2dt;\n\n        ax.d2p = ax.r2p = function(v, _, calendar) { return ax.l2p(dt2ms(v, 0, calendar)); };\n        ax.p2d = ax.p2r = function(px, r, calendar) { return ms2dt(p2l(px), r, calendar); };\n\n        ax.cleanPos = function(v) { return Lib.cleanDate(v, BADNUM, ax.calendar); };\n    } else if(ax.type === 'category') {\n        // d is categories (string)\n        // c and l are indices (numbers)\n        // r is categories or numbers\n\n        ax.d2c = ax.d2l = setCategoryIndex;\n        ax.r2d = ax.c2d = ax.l2d = getCategoryName;\n\n        ax.d2r = ax.d2l_noadd = getCategoryPosition;\n\n        ax.r2c = function(v) {\n            var index = getRangePosition(v);\n            return index !== undefined ? index : ax.fraction2r(0.5);\n        };\n\n        ax.l2r = ax.c2r = ensureNumber;\n        ax.r2l = getRangePosition;\n\n        ax.d2p = function(v) { return ax.l2p(ax.r2c(v)); };\n        ax.p2d = function(px) { return getCategoryName(p2l(px)); };\n        ax.r2p = ax.d2p;\n        ax.p2r = p2l;\n\n        ax.cleanPos = function(v) {\n            if(typeof v === 'string' && v !== '') return v;\n            return ensureNumber(v);\n        };\n    } else if(ax.type === 'multicategory') {\n        // N.B. multicategory axes don't define d2c and d2l,\n        // as 'data-to-calcdata' conversion needs to take into\n        // account all data array items as in ax.makeCalcdata.\n\n        ax.r2d = ax.c2d = ax.l2d = getCategoryName;\n        ax.d2r = ax.d2l_noadd = getCategoryPosition;\n\n        ax.r2c = function(v) {\n            var index = getCategoryPosition(v);\n            return index !== undefined ? index : ax.fraction2r(0.5);\n        };\n\n        ax.r2c_just_indices = getCategoryIndex;\n\n        ax.l2r = ax.c2r = ensureNumber;\n        ax.r2l = getCategoryPosition;\n\n        ax.d2p = function(v) { return ax.l2p(ax.r2c(v)); };\n        ax.p2d = function(px) { return getCategoryName(p2l(px)); };\n        ax.r2p = ax.d2p;\n        ax.p2r = p2l;\n\n        ax.cleanPos = function(v) {\n            if(Array.isArray(v) || (typeof v === 'string' && v !== '')) return v;\n            return ensureNumber(v);\n        };\n\n        ax.setupMultiCategory = function(fullData) {\n            var traceIndices = ax._traceIndices;\n            var i, j;\n\n            var group = ax._matchGroup;\n            if(group && ax._categories.length === 0) {\n                for(var axId2 in group) {\n                    if(axId2 !== axId) {\n                        var ax2 = fullLayout[axisIds.id2name(axId2)];\n                        traceIndices = traceIndices.concat(ax2._traceIndices);\n                    }\n                }\n            }\n\n            // [ [cnt, {$cat: index}], for 1,2 ]\n            var seen = [[0, {}], [0, {}]];\n            // [ [arrayIn[0][i], arrayIn[1][i]], for i .. N ]\n            var list = [];\n\n            for(i = 0; i < traceIndices.length; i++) {\n                var trace = fullData[traceIndices[i]];\n\n                if(axLetter in trace) {\n                    var arrayIn = trace[axLetter];\n                    var len = trace._length || Lib.minRowLength(arrayIn);\n\n                    if(isArrayOrTypedArray(arrayIn[0]) && isArrayOrTypedArray(arrayIn[1])) {\n                        for(j = 0; j < len; j++) {\n                            var v0 = arrayIn[0][j];\n                            var v1 = arrayIn[1][j];\n\n                            if(isValidCategory(v0) && isValidCategory(v1)) {\n                                list.push([v0, v1]);\n\n                                if(!(v0 in seen[0][1])) {\n                                    seen[0][1][v0] = seen[0][0]++;\n                                }\n                                if(!(v1 in seen[1][1])) {\n                                    seen[1][1][v1] = seen[1][0]++;\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n\n            list.sort(function(a, b) {\n                var ind0 = seen[0][1];\n                var d = ind0[a[0]] - ind0[b[0]];\n                if(d) return d;\n\n                var ind1 = seen[1][1];\n                return ind1[a[1]] - ind1[b[1]];\n            });\n\n            for(i = 0; i < list.length; i++) {\n                setCategoryIndex(list[i]);\n            }\n        };\n    }\n\n    // find the range value at the specified (linear) fraction of the axis\n    ax.fraction2r = function(v) {\n        var rl0 = ax.r2l(ax.range[0]);\n        var rl1 = ax.r2l(ax.range[1]);\n        return ax.l2r(rl0 + v * (rl1 - rl0));\n    };\n\n    // find the fraction of the range at the specified range value\n    ax.r2fraction = function(v) {\n        var rl0 = ax.r2l(ax.range[0]);\n        var rl1 = ax.r2l(ax.range[1]);\n        return (ax.r2l(v) - rl0) / (rl1 - rl0);\n    };\n\n    ax.limitRange = function(rangeAttr) {\n        var minallowed = ax.minallowed;\n        var maxallowed = ax.maxallowed;\n        if(minallowed === undefined && maxallowed === undefined) return;\n\n        if(!rangeAttr) rangeAttr = 'range';\n        var range = Lib.nestedProperty(ax, rangeAttr).get();\n        var rng = Lib.simpleMap(range, ax.r2l);\n        var axrev = rng[1] < rng[0];\n        if(axrev) rng.reverse();\n\n        var bounds = Lib.simpleMap([minallowed, maxallowed], ax.r2l);\n\n        if(minallowed !== undefined && rng[0] < bounds[0]) range[axrev ? 1 : 0] = minallowed;\n        if(maxallowed !== undefined && rng[1] > bounds[1]) range[axrev ? 0 : 1] = maxallowed;\n\n        if(range[0] === range[1]) {\n            var minL = ax.l2r(minallowed);\n            var maxL = ax.l2r(maxallowed);\n\n            if(minallowed !== undefined) {\n                var _max = minL + 1;\n                if(maxallowed !== undefined) _max = Math.min(_max, maxL);\n                range[axrev ? 1 : 0] = _max;\n            }\n\n            if(maxallowed !== undefined) {\n                var _min = maxL + 1;\n                if(minallowed !== undefined) _min = Math.max(_min, minL);\n                range[axrev ? 0 : 1] = _min;\n            }\n        }\n    };\n\n    /*\n     * cleanRange: make sure range is a couplet of valid & distinct values\n     * keep numbers away from the limits of floating point numbers,\n     * and dates away from the ends of our date system (+/- 9999 years)\n     *\n     * optional param rangeAttr: operate on a different attribute, like\n     * ax._r, rather than ax.range\n     */\n    ax.cleanRange = function(rangeAttr, opts) {\n        ax._cleanRange(rangeAttr, opts);\n        ax.limitRange(rangeAttr);\n    };\n\n    ax._cleanRange = function(rangeAttr, opts) {\n        if(!opts) opts = {};\n        if(!rangeAttr) rangeAttr = 'range';\n\n        var range = Lib.nestedProperty(ax, rangeAttr).get();\n        var i, dflt;\n\n        if(ax.type === 'date') dflt = Lib.dfltRange(ax.calendar);\n        else if(axLetter === 'y') dflt = constants.DFLTRANGEY;\n        else if(ax._name === 'realaxis') dflt = [0, 1];\n        else dflt = opts.dfltRange || constants.DFLTRANGEX;\n\n        // make sure we don't later mutate the defaults\n        dflt = dflt.slice();\n\n        if(ax.rangemode === 'tozero' || ax.rangemode === 'nonnegative') {\n            dflt[0] = 0;\n        }\n\n        if(!range || range.length !== 2) {\n            Lib.nestedProperty(ax, rangeAttr).set(dflt);\n            return;\n        }\n\n        var nullRange0 = range[0] === null;\n        var nullRange1 = range[1] === null;\n\n        if(ax.type === 'date' && !ax.autorange) {\n            // check if milliseconds or js date objects are provided for range\n            // and convert to date strings\n            range[0] = Lib.cleanDate(range[0], BADNUM, ax.calendar);\n            range[1] = Lib.cleanDate(range[1], BADNUM, ax.calendar);\n        }\n\n        for(i = 0; i < 2; i++) {\n            if(ax.type === 'date') {\n                if(!Lib.isDateTime(range[i], ax.calendar)) {\n                    ax[rangeAttr] = dflt;\n                    break;\n                }\n\n                if(ax.r2l(range[0]) === ax.r2l(range[1])) {\n                    // split by +/- 1 second\n                    var linCenter = Lib.constrain(ax.r2l(range[0]),\n                        Lib.MIN_MS + 1000, Lib.MAX_MS - 1000);\n                    range[0] = ax.l2r(linCenter - 1000);\n                    range[1] = ax.l2r(linCenter + 1000);\n                    break;\n                }\n            } else {\n                if(!isNumeric(range[i])) {\n                    if(!(nullRange0 || nullRange1) && isNumeric(range[1 - i])) {\n                        range[i] = range[1 - i] * (i ? 10 : 0.1);\n                    } else {\n                        ax[rangeAttr] = dflt;\n                        break;\n                    }\n                }\n\n                if(range[i] < -FP_SAFE) range[i] = -FP_SAFE;\n                else if(range[i] > FP_SAFE) range[i] = FP_SAFE;\n\n                if(range[0] === range[1]) {\n                    // somewhat arbitrary: split by 1 or 1ppm, whichever is bigger\n                    var inc = Math.max(1, Math.abs(range[0] * 1e-6));\n                    range[0] -= inc;\n                    range[1] += inc;\n                }\n            }\n        }\n    };\n\n    // set scaling to pixels\n    ax.setScale = function(usePrivateRange) {\n        var gs = fullLayout._size;\n\n        // make sure we have a domain (pull it in from the axis\n        // this one is overlaying if necessary)\n        if(ax.overlaying) {\n            var ax2 = axisIds.getFromId({ _fullLayout: fullLayout }, ax.overlaying);\n            ax.domain = ax2.domain;\n        }\n\n        // While transitions are occurring, we get a double-transform\n        // issue if we transform the drawn layer *and* use the new axis range to\n        // draw the data. This allows us to construct setConvert using the pre-\n        // interaction values of the range:\n        var rangeAttr = (usePrivateRange && ax._r) ? '_r' : 'range';\n        var calendar = ax.calendar;\n        ax.cleanRange(rangeAttr);\n\n        var rl0 = ax.r2l(ax[rangeAttr][0], calendar);\n        var rl1 = ax.r2l(ax[rangeAttr][1], calendar);\n\n        var isY = axLetter === 'y';\n        if(isY) {\n            ax._offset = gs.t + (1 - ax.domain[1]) * gs.h;\n            ax._length = gs.h * (ax.domain[1] - ax.domain[0]);\n            ax._m = ax._length / (rl0 - rl1);\n            ax._b = -ax._m * rl1;\n        } else {\n            ax._offset = gs.l + ax.domain[0] * gs.w;\n            ax._length = gs.w * (ax.domain[1] - ax.domain[0]);\n            ax._m = ax._length / (rl1 - rl0);\n            ax._b = -ax._m * rl0;\n        }\n\n        // set of \"N\" disjoint rangebreaks inside the range\n        ax._rangebreaks = [];\n        // length of these rangebreaks in value space - negative on reversed axes\n        ax._lBreaks = 0;\n        // l2p slope (same for all intervals)\n        ax._m2 = 0;\n        // set of l2p offsets (one for each of the (N+1) piecewise intervals)\n        ax._B = [];\n\n        if(ax.rangebreaks) {\n            var i, brk;\n\n            ax._rangebreaks = ax.locateBreaks(\n                Math.min(rl0, rl1),\n                Math.max(rl0, rl1)\n            );\n\n            if(ax._rangebreaks.length) {\n                for(i = 0; i < ax._rangebreaks.length; i++) {\n                    brk = ax._rangebreaks[i];\n                    ax._lBreaks += Math.abs(brk.max - brk.min);\n                }\n\n                var flip = isY;\n                if(rl0 > rl1) flip = !flip;\n                if(flip) ax._rangebreaks.reverse();\n                var sign = flip ? -1 : 1;\n\n                ax._m2 = sign * ax._length / (Math.abs(rl1 - rl0) - ax._lBreaks);\n                ax._B.push(-ax._m2 * (isY ? rl1 : rl0));\n                for(i = 0; i < ax._rangebreaks.length; i++) {\n                    brk = ax._rangebreaks[i];\n                    ax._B.push(\n                        ax._B[ax._B.length - 1] -\n                        sign * ax._m2 * (brk.max - brk.min)\n                    );\n                }\n\n                // fill pixel (i.e. 'p') min/max here,\n                // to not have to loop through the _rangebreaks twice during `p2l`\n                for(i = 0; i < ax._rangebreaks.length; i++) {\n                    brk = ax._rangebreaks[i];\n                    brk.pmin = l2p(brk.min);\n                    brk.pmax = l2p(brk.max);\n                }\n            }\n        }\n\n        if(!isFinite(ax._m) || !isFinite(ax._b) || ax._length < 0) {\n            fullLayout._replotting = false;\n            throw new Error('Something went wrong with axis scaling');\n        }\n    };\n\n    ax.maskBreaks = function(v) {\n        var rangebreaksIn = ax.rangebreaks || [];\n        var bnds, b0, b1, vb, vDate;\n\n\n        if(!rangebreaksIn._cachedPatterns) {\n            rangebreaksIn._cachedPatterns = rangebreaksIn.map(function(brk) {\n                return brk.enabled && brk.bounds ? Lib.simpleMap(brk.bounds, brk.pattern ?\n                    cleanNumber :\n                    ax.d2c // case of pattern: ''\n                ) : null;\n            });\n        }\n        if(!rangebreaksIn._cachedValues) {\n            rangebreaksIn._cachedValues = rangebreaksIn.map(function(brk) {\n                return brk.enabled && brk.values ? Lib.simpleMap(brk.values, ax.d2c).sort(Lib.sorterAsc) : null;\n            });\n        }\n\n\n        for(var i = 0; i < rangebreaksIn.length; i++) {\n            var brk = rangebreaksIn[i];\n\n            if(brk.enabled) {\n                if(brk.bounds) {\n                    var pattern = brk.pattern;\n                    bnds = rangebreaksIn._cachedPatterns[i];\n                    b0 = bnds[0];\n                    b1 = bnds[1];\n\n                    switch(pattern) {\n                        case WEEKDAY_PATTERN:\n                            vDate = new Date(v);\n                            vb = vDate.getUTCDay();\n\n                            if(b0 > b1) {\n                                b1 += 7;\n                                if(vb < b0) vb += 7;\n                            }\n\n                            break;\n                        case HOUR_PATTERN:\n                            vDate = new Date(v);\n                            var hours = vDate.getUTCHours();\n                            var minutes = vDate.getUTCMinutes();\n                            var seconds = vDate.getUTCSeconds();\n                            var milliseconds = vDate.getUTCMilliseconds();\n\n                            vb = hours + (\n                                minutes / 60 +\n                                seconds / 3600 +\n                                milliseconds / 3600000\n                            );\n\n                            if(b0 > b1) {\n                                b1 += 24;\n                                if(vb < b0) vb += 24;\n                            }\n\n                            break;\n                        case '':\n                            // N.B. should work on date axes as well!\n                            // e.g. { bounds: ['2020-01-04', '2020-01-05 23:59'] }\n                            // TODO should work with reversed-range axes\n                            vb = v;\n                            break;\n                    }\n\n                    if(vb >= b0 && vb < b1) return BADNUM;\n                } else {\n                    var vals = rangebreaksIn._cachedValues[i];\n                    for(var j = 0; j < vals.length; j++) {\n                        b0 = vals[j];\n                        b1 = b0 + brk.dvalue;\n                        if(v >= b0 && v < b1) return BADNUM;\n                    }\n                }\n            }\n        }\n        return v;\n    };\n\n    ax.locateBreaks = function(r0, r1) {\n        var i, bnds, b0, b1;\n\n        var rangebreaksOut = [];\n        if(!ax.rangebreaks) return rangebreaksOut;\n\n        var rangebreaksIn = ax.rangebreaks.slice().sort(function(a, b) {\n            if(a.pattern === WEEKDAY_PATTERN && b.pattern === HOUR_PATTERN) return -1;\n            if(b.pattern === WEEKDAY_PATTERN && a.pattern === HOUR_PATTERN) return 1;\n            return 0;\n        });\n\n        var addBreak = function(min, max) {\n            min = Lib.constrain(min, r0, r1);\n            max = Lib.constrain(max, r0, r1);\n            if(min === max) return;\n\n            var isNewBreak = true;\n            for(var j = 0; j < rangebreaksOut.length; j++) {\n                var brkj = rangebreaksOut[j];\n                if(min < brkj.max && max >= brkj.min) {\n                    if(min < brkj.min) {\n                        brkj.min = min;\n                    }\n                    if(max > brkj.max) {\n                        brkj.max = max;\n                    }\n                    isNewBreak = false;\n                }\n            }\n            if(isNewBreak) {\n                rangebreaksOut.push({min: min, max: max});\n            }\n        };\n\n        for(i = 0; i < rangebreaksIn.length; i++) {\n            var brk = rangebreaksIn[i];\n\n            if(brk.enabled) {\n                if(brk.bounds) {\n                    var t0 = r0;\n                    var t1 = r1;\n                    if(brk.pattern) {\n                        // to remove decimal (most often found in auto ranges)\n                        t0 = Math.floor(t0);\n                    }\n\n                    bnds = Lib.simpleMap(brk.bounds, brk.pattern ? cleanNumber : ax.r2l);\n                    b0 = bnds[0];\n                    b1 = bnds[1];\n\n                    // r0 value as date\n                    var t0Date = new Date(t0);\n                    // r0 value for break pattern\n                    var bndDelta;\n                    // step in ms between rangebreaks\n                    var step;\n\n                    switch(brk.pattern) {\n                        case WEEKDAY_PATTERN:\n                            step = ONEWEEK;\n\n                            bndDelta = (\n                                (b1 < b0 ? 7 : 0) +\n                                (b1 - b0)\n                            ) * ONEDAY;\n\n                            t0 += b0 * ONEDAY - (\n                                t0Date.getUTCDay() * ONEDAY +\n                                t0Date.getUTCHours() * ONEHOUR +\n                                t0Date.getUTCMinutes() * ONEMIN +\n                                t0Date.getUTCSeconds() * ONESEC +\n                                t0Date.getUTCMilliseconds()\n                            );\n                            break;\n                        case HOUR_PATTERN:\n                            step = ONEDAY;\n\n                            bndDelta = (\n                                (b1 < b0 ? 24 : 0) +\n                                (b1 - b0)\n                            ) * ONEHOUR;\n\n                            t0 += b0 * ONEHOUR - (\n                                t0Date.getUTCHours() * ONEHOUR +\n                                t0Date.getUTCMinutes() * ONEMIN +\n                                t0Date.getUTCSeconds() * ONESEC +\n                                t0Date.getUTCMilliseconds()\n                            );\n                            break;\n                        default:\n                            t0 = Math.min(bnds[0], bnds[1]);\n                            t1 = Math.max(bnds[0], bnds[1]);\n                            step = t1 - t0;\n                            bndDelta = step;\n                    }\n\n                    for(var t = t0; t < t1; t += step) {\n                        addBreak(t, t + bndDelta);\n                    }\n                } else {\n                    var vals = Lib.simpleMap(brk.values, ax.d2c);\n                    for(var j = 0; j < vals.length; j++) {\n                        b0 = vals[j];\n                        b1 = b0 + brk.dvalue;\n                        addBreak(b0, b1);\n                    }\n                }\n            }\n        }\n\n        rangebreaksOut.sort(function(a, b) { return a.min - b.min; });\n\n        return rangebreaksOut;\n    };\n\n    // makeCalcdata: takes an x or y array and converts it\n    // to a position on the axis object \"ax\"\n    // inputs:\n    //      trace - a data object from gd.data\n    //      axLetter - a string, either 'x' or 'y', for which item\n    //          to convert (TODO: is this now always the same as\n    //          the first letter of ax._id?)\n    // in case the expected data isn't there, make a list of\n    // integers based on the opposite data\n    ax.makeCalcdata = function(trace, axLetter, opts) {\n        var arrayIn, arrayOut, i, len;\n\n        var axType = ax.type;\n        var cal = axType === 'date' && trace[axLetter + 'calendar'];\n\n        if(axLetter in trace) {\n            arrayIn = trace[axLetter];\n            len = trace._length || Lib.minRowLength(arrayIn);\n\n            if(Lib.isTypedArray(arrayIn) && (axType === 'linear' || axType === 'log')) {\n                if(len === arrayIn.length) {\n                    return arrayIn;\n                } else if(arrayIn.subarray) {\n                    return arrayIn.subarray(0, len);\n                }\n            }\n\n            if(axType === 'multicategory') {\n                return setMultiCategoryIndex(arrayIn, len);\n            }\n\n            arrayOut = new Array(len);\n            for(i = 0; i < len; i++) {\n                arrayOut[i] = ax.d2c(arrayIn[i], 0, cal, opts);\n            }\n        } else {\n            var v0 = ((axLetter + '0') in trace) ? ax.d2c(trace[axLetter + '0'], 0, cal) : 0;\n            var dv = (trace['d' + axLetter]) ? Number(trace['d' + axLetter]) : 1;\n\n            // the opposing data, for size if we have x and dx etc\n            arrayIn = trace[{x: 'y', y: 'x'}[axLetter]];\n            len = trace._length || arrayIn.length;\n            arrayOut = new Array(len);\n\n            for(i = 0; i < len; i++) {\n                arrayOut[i] = v0 + i * dv;\n            }\n        }\n\n        // mask (i.e. set to BADNUM) coords that fall inside rangebreaks\n        if(ax.rangebreaks) {\n            for(i = 0; i < len; i++) {\n                arrayOut[i] = ax.maskBreaks(arrayOut[i]);\n            }\n        }\n\n        return arrayOut;\n    };\n\n    ax.isValidRange = function(range, nullOk) {\n        return (\n            Array.isArray(range) &&\n            range.length === 2 &&\n            ((nullOk && range[0] === null) || isNumeric(ax.r2l(range[0]))) &&\n            ((nullOk && range[1] === null) || isNumeric(ax.r2l(range[1])))\n        );\n    };\n\n    ax.getAutorangeDflt = function(range, options) {\n        var autorangeDflt = !ax.isValidRange(range, 'nullOk');\n        if(autorangeDflt && options && options.reverseDflt) autorangeDflt = 'reversed';\n        else if(range) {\n            if(range[0] === null && range[1] === null) {\n                autorangeDflt = true;\n            } else if(range[0] === null && range[1] !== null) {\n                autorangeDflt = 'min';\n            } else if(range[0] !== null && range[1] === null) {\n                autorangeDflt = 'max';\n            }\n        }\n        return autorangeDflt;\n    };\n\n    ax.isReversed = function() {\n        var autorange = ax.autorange;\n        return (\n            autorange === 'reversed' ||\n            autorange === 'min reversed' ||\n            autorange === 'max reversed'\n        );\n    };\n\n    ax.isPtWithinRange = function(d, calendar) {\n        var coord = ax.c2l(d[axLetter], null, calendar);\n        var r0 = ax.r2l(ax.range[0]);\n        var r1 = ax.r2l(ax.range[1]);\n\n        if(r0 < r1) {\n            return r0 <= coord && coord <= r1;\n        } else {\n            // Reversed axis case.\n            return r1 <= coord && coord <= r0;\n        }\n    };\n\n    ax._emptyCategories = function() {\n        ax._categories = [];\n        ax._categoriesMap = {};\n    };\n\n    // should skip if not category nor multicategory\n    ax.clearCalc = function() {\n        var group = ax._matchGroup;\n        if(group) {\n            var categories = null;\n            var categoriesMap = null;\n\n            for(var axId2 in group) {\n                var ax2 = fullLayout[axisIds.id2name(axId2)];\n                if(ax2._categories) {\n                    categories = ax2._categories;\n                    categoriesMap = ax2._categoriesMap;\n                    break;\n                }\n            }\n\n            if(categories && categoriesMap) {\n                ax._categories = categories;\n                ax._categoriesMap = categoriesMap;\n            } else {\n                ax._emptyCategories();\n            }\n        } else {\n            ax._emptyCategories();\n        }\n\n        if(ax._initialCategories) {\n            for(var j = 0; j < ax._initialCategories.length; j++) {\n                setCategoryIndex(ax._initialCategories[j]);\n            }\n        }\n    };\n\n    // sort the axis (and all the matching ones) by _initialCategories\n    // returns the indices of the traces affected by the reordering\n    ax.sortByInitialCategories = function() {\n        var affectedTraces = [];\n\n        ax._emptyCategories();\n\n        if(ax._initialCategories) {\n            for(var j = 0; j < ax._initialCategories.length; j++) {\n                setCategoryIndex(ax._initialCategories[j]);\n            }\n        }\n\n        affectedTraces = affectedTraces.concat(ax._traceIndices);\n\n        // Propagate to matching axes\n        var group = ax._matchGroup;\n        for(var axId2 in group) {\n            if(axId === axId2) continue;\n            var ax2 = fullLayout[axisIds.id2name(axId2)];\n            ax2._categories = ax._categories;\n            ax2._categoriesMap = ax._categoriesMap;\n            affectedTraces = affectedTraces.concat(ax2._traceIndices);\n        }\n        return affectedTraces;\n    };\n\n    // Propagate localization into the axis so that\n    // methods in Axes can use it w/o having to pass fullLayout\n    // Default (non-d3) number formatting uses separators directly\n    // dates and d3-formatted numbers use the d3 locale\n    // Fall back on default format for dummy axes that don't care about formatting\n    var locale = fullLayout._d3locale;\n    if(ax.type === 'date') {\n        ax._dateFormat = locale ? locale.timeFormat : utcFormat;\n        ax._extraFormat = fullLayout._extraFormat;\n    }\n    // occasionally we need _numFormat to pass through\n    // even though it won't be needed by this axis\n    ax._separators = fullLayout.separators;\n    ax._numFormat = locale ? locale.numberFormat : numberFormat;\n\n    // and for bar charts and box plots: reset forced minimum tick spacing\n    delete ax._minDtick;\n    delete ax._forceTick0;\n};\n","'use strict';\n\n/*\n * Attributes 'showexponent', 'showtickprefix' and 'showticksuffix'\n * share values.\n *\n * If only 1 attribute is set,\n * the remaining attributes inherit that value.\n *\n * If 2 attributes are set to the same value,\n * the remaining attribute inherits that value.\n *\n * If 2 attributes are set to different values,\n * the remaining is set to its dflt value.\n *\n */\nmodule.exports = function getShowAttrDflt(containerIn) {\n    var showAttrsAll = ['showexponent', 'showtickprefix', 'showticksuffix'];\n    var showAttrs = showAttrsAll.filter(function(a) {\n        return containerIn[a] !== undefined;\n    });\n    var sameVal = function(a) {\n        return containerIn[a] === containerIn[showAttrs[0]];\n    };\n\n    if(showAttrs.every(sameVal) || showAttrs.length === 1) {\n        return containerIn[showAttrs[0]];\n    }\n};\n","'use strict';\n\nvar Lib = require('../../lib');\nvar contrast = require('../../components/color').contrast;\nvar layoutAttributes = require('./layout_attributes');\nvar getShowAttrDflt = require('./show_dflt');\nvar handleArrayContainerDefaults = require('../array_container_defaults');\n\nmodule.exports = function handleTickLabelDefaults(containerIn, containerOut, coerce, axType, options) {\n    if(!options) options = {};\n\n    var labelalias = coerce('labelalias');\n    if(!Lib.isPlainObject(labelalias)) delete containerOut.labelalias;\n\n    var showAttrDflt = getShowAttrDflt(containerIn);\n\n    var showTickLabels = coerce('showticklabels');\n    if(showTickLabels) {\n        var font = options.font || {};\n        var contColor = containerOut.color;\n        var position = containerOut.ticklabelposition || '';\n        var dfltFontColor = position.indexOf('inside') !== -1 ?\n            contrast(options.bgColor) :\n            // as with titlefont.color, inherit axis.color only if one was\n            // explicitly provided\n            (contColor && contColor !== layoutAttributes.color.dflt) ?\n            contColor : font.color;\n\n        Lib.coerceFont(coerce, 'tickfont', {\n            family: font.family,\n            size: font.size,\n            color: dfltFontColor\n        });\n\n        if(\n            !options.noTicklabelstep &&\n            axType !== 'multicategory' &&\n            axType !== 'log'\n        ) {\n            coerce('ticklabelstep');\n        }\n\n        if(!options.noAng) {\n            var tickAngle = coerce('tickangle');\n            if(!options.noAutotickangles && tickAngle === 'auto') {\n                coerce('autotickangles');\n            }\n        }\n\n        if(axType !== 'category') {\n            var tickFormat = coerce('tickformat');\n\n            handleArrayContainerDefaults(containerIn, containerOut, {\n                name: 'tickformatstops',\n                inclusionAttr: 'enabled',\n                handleItemDefaults: tickformatstopDefaults\n            });\n            if(!containerOut.tickformatstops.length) {\n                delete containerOut.tickformatstops;\n            }\n\n            if(!options.noExp && !tickFormat && axType !== 'date') {\n                coerce('showexponent', showAttrDflt);\n                coerce('exponentformat');\n                coerce('minexponent');\n                coerce('separatethousands');\n            }\n        }\n    }\n};\n\nfunction tickformatstopDefaults(valueIn, valueOut) {\n    function coerce(attr, dflt) {\n        return Lib.coerce(valueIn, valueOut, layoutAttributes.tickformatstops, attr, dflt);\n    }\n\n    var enabled = coerce('enabled');\n    if(enabled) {\n        coerce('dtickrange');\n        coerce('value');\n    }\n}\n","'use strict';\n\nvar Lib = require('../../lib');\n\nvar layoutAttributes = require('./layout_attributes');\n\n\n/**\n * options: inherits outerTicks from axes.handleAxisDefaults\n */\nmodule.exports = function handleTickMarkDefaults(containerIn, containerOut, coerce, options) {\n    var isMinor = options.isMinor;\n    var cIn = isMinor ? containerIn.minor || {} : containerIn;\n    var cOut = isMinor ? containerOut.minor : containerOut;\n    var lAttr = isMinor ? layoutAttributes.minor : layoutAttributes;\n    var prefix = isMinor ? 'minor.' : '';\n\n    var tickLen = Lib.coerce2(cIn, cOut, lAttr, 'ticklen', isMinor ? ((containerOut.ticklen || 5) * 0.6) : undefined);\n    var tickWidth = Lib.coerce2(cIn, cOut, lAttr, 'tickwidth', isMinor ? (containerOut.tickwidth || 1) : undefined);\n    var tickColor = Lib.coerce2(cIn, cOut, lAttr, 'tickcolor', (isMinor ? containerOut.tickcolor : undefined) || cOut.color);\n    var showTicks = coerce(prefix + 'ticks', (\n        (!isMinor && options.outerTicks) || tickLen || tickWidth || tickColor\n    ) ? 'outside' : '');\n\n    if(!showTicks) {\n        delete cOut.ticklen;\n        delete cOut.tickwidth;\n        delete cOut.tickcolor;\n    }\n};\n","'use strict';\n\nvar cleanTicks = require('./clean_ticks');\nvar isArrayOrTypedArray = require('../../lib').isArrayOrTypedArray;\nvar isTypedArraySpec = require('../../lib/array').isTypedArraySpec;\nvar decodeTypedArraySpec = require('../../lib/array').decodeTypedArraySpec;\n\nmodule.exports = function handleTickValueDefaults(containerIn, containerOut, coerce, axType, opts) {\n    if(!opts) opts = {};\n    var isMinor = opts.isMinor;\n    var cIn = isMinor ? containerIn.minor || {} : containerIn;\n    var cOut = isMinor ? containerOut.minor : containerOut;\n    var prefix = isMinor ? 'minor.' : '';\n\n    function readInput(attr) {\n        var v = cIn[attr];\n        if(isTypedArraySpec(v)) v = decodeTypedArraySpec(v);\n\n        return (\n            v !== undefined\n        ) ? v : (cOut._template || {})[attr];\n    }\n\n    var _tick0 = readInput('tick0');\n    var _dtick = readInput('dtick');\n    var _tickvals = readInput('tickvals');\n\n    var tickmodeDefault = isArrayOrTypedArray(_tickvals) ? 'array' :\n        _dtick ? 'linear' :\n        'auto';\n    var tickmode = coerce(prefix + 'tickmode', tickmodeDefault);\n\n    if(tickmode === 'auto' || tickmode === 'sync') {\n        coerce(prefix + 'nticks');\n    } else if(tickmode === 'linear') {\n        // dtick is usually a positive number, but there are some\n        // special strings available for log or date axes\n        // tick0 also has special logic\n        var dtick = cOut.dtick = cleanTicks.dtick(\n            _dtick, axType);\n        cOut.tick0 = cleanTicks.tick0(\n            _tick0, axType, containerOut.calendar, dtick);\n    } else if(axType !== 'multicategory') {\n        var tickvals = coerce(prefix + 'tickvals');\n        if(tickvals === undefined) cOut.tickmode = 'auto';\n        else if(!isMinor) coerce('ticktext');\n    }\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\n\nvar Registry = require('../../registry');\nvar Lib = require('../../lib');\nvar Drawing = require('../../components/drawing');\nvar Axes = require('./axes');\n\n/**\n * transitionAxes\n *\n * transition axes from one set of ranges to another, using a svg\n * transformations, similar to during panning.\n *\n * @param {DOM element | object} gd\n * @param {array} edits : array of 'edits', each item with\n * - plotinfo {object} subplot object\n * - xr0 {array} initial x-range\n * - xr1 {array} end x-range\n * - yr0 {array} initial y-range\n * - yr1 {array} end y-range\n * @param {object} transitionOpts\n * @param {function} makeOnCompleteCallback\n */\nmodule.exports = function transitionAxes(gd, edits, transitionOpts, makeOnCompleteCallback) {\n    var fullLayout = gd._fullLayout;\n\n    // special case for redraw:false Plotly.animate that relies on this\n    // to update axis-referenced layout components\n    if(edits.length === 0) {\n        Axes.redrawComponents(gd);\n        return;\n    }\n\n    function unsetSubplotTransform(subplot) {\n        var xa = subplot.xaxis;\n        var ya = subplot.yaxis;\n\n        fullLayout._defs.select('#' + subplot.clipId + '> rect')\n            .call(Drawing.setTranslate, 0, 0)\n            .call(Drawing.setScale, 1, 1);\n\n        subplot.plot\n            .call(Drawing.setTranslate, xa._offset, ya._offset)\n            .call(Drawing.setScale, 1, 1);\n\n        var traceGroups = subplot.plot.selectAll('.scatterlayer .trace');\n\n        // This is specifically directed at scatter traces, applying an inverse\n        // scale to individual points to counteract the scale of the trace\n        // as a whole:\n        traceGroups.selectAll('.point')\n            .call(Drawing.setPointGroupScale, 1, 1);\n        traceGroups.selectAll('.textpoint')\n            .call(Drawing.setTextPointsScale, 1, 1);\n        traceGroups\n            .call(Drawing.hideOutsideRangePoints, subplot);\n    }\n\n    function updateSubplot(edit, progress) {\n        var plotinfo = edit.plotinfo;\n        var xa = plotinfo.xaxis;\n        var ya = plotinfo.yaxis;\n        var xlen = xa._length;\n        var ylen = ya._length;\n        var editX = !!edit.xr1;\n        var editY = !!edit.yr1;\n        var viewBox = [];\n\n        if(editX) {\n            var xr0 = Lib.simpleMap(edit.xr0, xa.r2l);\n            var xr1 = Lib.simpleMap(edit.xr1, xa.r2l);\n            var dx0 = xr0[1] - xr0[0];\n            var dx1 = xr1[1] - xr1[0];\n            viewBox[0] = (xr0[0] * (1 - progress) + progress * xr1[0] - xr0[0]) / (xr0[1] - xr0[0]) * xlen;\n            viewBox[2] = xlen * ((1 - progress) + progress * dx1 / dx0);\n            xa.range[0] = xa.l2r(xr0[0] * (1 - progress) + progress * xr1[0]);\n            xa.range[1] = xa.l2r(xr0[1] * (1 - progress) + progress * xr1[1]);\n        } else {\n            viewBox[0] = 0;\n            viewBox[2] = xlen;\n        }\n\n        if(editY) {\n            var yr0 = Lib.simpleMap(edit.yr0, ya.r2l);\n            var yr1 = Lib.simpleMap(edit.yr1, ya.r2l);\n            var dy0 = yr0[1] - yr0[0];\n            var dy1 = yr1[1] - yr1[0];\n            viewBox[1] = (yr0[1] * (1 - progress) + progress * yr1[1] - yr0[1]) / (yr0[0] - yr0[1]) * ylen;\n            viewBox[3] = ylen * ((1 - progress) + progress * dy1 / dy0);\n            ya.range[0] = xa.l2r(yr0[0] * (1 - progress) + progress * yr1[0]);\n            ya.range[1] = ya.l2r(yr0[1] * (1 - progress) + progress * yr1[1]);\n        } else {\n            viewBox[1] = 0;\n            viewBox[3] = ylen;\n        }\n\n        Axes.drawOne(gd, xa, {skipTitle: true});\n        Axes.drawOne(gd, ya, {skipTitle: true});\n        Axes.redrawComponents(gd, [xa._id, ya._id]);\n\n        var xScaleFactor = editX ? xlen / viewBox[2] : 1;\n        var yScaleFactor = editY ? ylen / viewBox[3] : 1;\n        var clipDx = editX ? viewBox[0] : 0;\n        var clipDy = editY ? viewBox[1] : 0;\n        var fracDx = editX ? (viewBox[0] / viewBox[2] * xlen) : 0;\n        var fracDy = editY ? (viewBox[1] / viewBox[3] * ylen) : 0;\n        var plotDx = xa._offset - fracDx;\n        var plotDy = ya._offset - fracDy;\n\n        plotinfo.clipRect\n            .call(Drawing.setTranslate, clipDx, clipDy)\n            .call(Drawing.setScale, 1 / xScaleFactor, 1 / yScaleFactor);\n\n        plotinfo.plot\n            .call(Drawing.setTranslate, plotDx, plotDy)\n            .call(Drawing.setScale, xScaleFactor, yScaleFactor);\n\n        // apply an inverse scale to individual points to counteract\n        // the scale of the trace group.\n        Drawing.setPointGroupScale(plotinfo.zoomScalePts, 1 / xScaleFactor, 1 / yScaleFactor);\n        Drawing.setTextPointsScale(plotinfo.zoomScaleTxt, 1 / xScaleFactor, 1 / yScaleFactor);\n    }\n\n    var onComplete;\n    if(makeOnCompleteCallback) {\n        // This module makes the choice whether or not it notifies Plotly.transition\n        // about completion:\n        onComplete = makeOnCompleteCallback();\n    }\n\n    function transitionComplete() {\n        var aobj = {};\n\n        for(var i = 0; i < edits.length; i++) {\n            var edit = edits[i];\n            var xa = edit.plotinfo.xaxis;\n            var ya = edit.plotinfo.yaxis;\n            if(edit.xr1) aobj[xa._name + '.range'] = edit.xr1.slice();\n            if(edit.yr1) aobj[ya._name + '.range'] = edit.yr1.slice();\n        }\n\n        // Signal that this transition has completed:\n        onComplete && onComplete();\n\n        return Registry.call('relayout', gd, aobj).then(function() {\n            for(var i = 0; i < edits.length; i++) {\n                unsetSubplotTransform(edits[i].plotinfo);\n            }\n        });\n    }\n\n    function transitionInterrupt() {\n        var aobj = {};\n\n        for(var i = 0; i < edits.length; i++) {\n            var edit = edits[i];\n            var xa = edit.plotinfo.xaxis;\n            var ya = edit.plotinfo.yaxis;\n            if(edit.xr0) aobj[xa._name + '.range'] = edit.xr0.slice();\n            if(edit.yr0) aobj[ya._name + '.range'] = edit.yr0.slice();\n        }\n\n        return Registry.call('relayout', gd, aobj).then(function() {\n            for(var i = 0; i < edits.length; i++) {\n                unsetSubplotTransform(edits[i].plotinfo);\n            }\n        });\n    }\n\n    var t1, t2, raf;\n    var easeFn = d3.ease(transitionOpts.easing);\n\n    gd._transitionData._interruptCallbacks.push(function() {\n        window.cancelAnimationFrame(raf);\n        raf = null;\n        return transitionInterrupt();\n    });\n\n    function doFrame() {\n        t2 = Date.now();\n\n        var tInterp = Math.min(1, (t2 - t1) / transitionOpts.duration);\n        var progress = easeFn(tInterp);\n\n        for(var i = 0; i < edits.length; i++) {\n            updateSubplot(edits[i], progress);\n        }\n\n        if(t2 - t1 > transitionOpts.duration) {\n            transitionComplete();\n            raf = window.cancelAnimationFrame(doFrame);\n        } else {\n            raf = window.requestAnimationFrame(doFrame);\n        }\n    }\n\n    t1 = Date.now();\n    raf = window.requestAnimationFrame(doFrame);\n\n    return Promise.resolve();\n};\n","'use strict';\n\nvar traceIs = require('../../registry').traceIs;\nvar autoType = require('./axis_autotype');\n\n/*\n *  data: the plot data to use in choosing auto type\n *  name: axis object name (ie 'xaxis') if one should be stored\n */\nmodule.exports = function handleTypeDefaults(containerIn, containerOut, coerce, options) {\n    coerce('autotypenumbers', options.autotypenumbersDflt);\n    var axType = coerce('type', (options.splomStash || {}).type);\n\n    if(axType === '-') {\n        setAutoType(containerOut, options.data);\n\n        if(containerOut.type === '-') {\n            containerOut.type = 'linear';\n        } else {\n            // copy autoType back to input axis\n            // note that if this object didn't exist\n            // in the input layout, we have to put it in\n            // this happens in the main supplyDefaults function\n            containerIn.type = containerOut.type;\n        }\n    }\n};\n\nfunction setAutoType(ax, data) {\n    // new logic: let people specify any type they want,\n    // only autotype if type is '-'\n    if(ax.type !== '-') return;\n\n    var id = ax._id;\n    var axLetter = id.charAt(0);\n    var i;\n\n    // support 3d\n    if(id.indexOf('scene') !== -1) id = axLetter;\n\n    var d0 = getFirstNonEmptyTrace(data, id, axLetter);\n    if(!d0) return;\n\n    // first check for histograms, as the count direction\n    // should always default to a linear axis\n    if(d0.type === 'histogram' &&\n        axLetter === {v: 'y', h: 'x'}[d0.orientation || 'v']\n    ) {\n        ax.type = 'linear';\n        return;\n    }\n\n    var calAttr = axLetter + 'calendar';\n    var calendar = d0[calAttr];\n    var opts = {noMultiCategory: !traceIs(d0, 'cartesian') || traceIs(d0, 'noMultiCategory')};\n\n    // To not confuse 2D x/y used for per-box sample points for multicategory coordinates\n    if(d0.type === 'box' && d0._hasPreCompStats &&\n        axLetter === {h: 'x', v: 'y'}[d0.orientation || 'v']\n    ) {\n        opts.noMultiCategory = true;\n    }\n\n    opts.autotypenumbers = ax.autotypenumbers;\n\n    // check all boxes on this x axis to see\n    // if they're dates, numbers, or categories\n    if(isBoxWithoutPositionCoords(d0, axLetter)) {\n        var posLetter = getBoxPosLetter(d0);\n        var boxPositions = [];\n\n        for(i = 0; i < data.length; i++) {\n            var trace = data[i];\n            if(!traceIs(trace, 'box-violin') || (trace[axLetter + 'axis'] || axLetter) !== id) continue;\n\n            if(trace[posLetter] !== undefined) boxPositions.push(trace[posLetter][0]);\n            else if(trace.name !== undefined) boxPositions.push(trace.name);\n            else boxPositions.push('text');\n\n            if(trace[calAttr] !== calendar) calendar = undefined;\n        }\n\n        ax.type = autoType(boxPositions, calendar, opts);\n    } else if(d0.type === 'splom') {\n        var dimensions = d0.dimensions;\n        var dim = dimensions[d0._axesDim[id]];\n        if(dim.visible) ax.type = autoType(dim.values, calendar, opts);\n    } else {\n        ax.type = autoType(d0[axLetter] || [d0[axLetter + '0']], calendar, opts);\n    }\n}\n\nfunction getFirstNonEmptyTrace(data, id, axLetter) {\n    for(var i = 0; i < data.length; i++) {\n        var trace = data[i];\n\n        if(trace.type === 'splom' &&\n                trace._length > 0 &&\n                (trace['_' + axLetter + 'axes'] || {})[id]\n        ) {\n            return trace;\n        }\n\n        if((trace[axLetter + 'axis'] || axLetter) === id) {\n            if(isBoxWithoutPositionCoords(trace, axLetter)) {\n                return trace;\n            } else if((trace[axLetter] || []).length || trace[axLetter + '0']) {\n                return trace;\n            }\n        }\n    }\n}\n\nfunction getBoxPosLetter(trace) {\n    return {v: 'x', h: 'y'}[trace.orientation || 'v'];\n}\n\nfunction isBoxWithoutPositionCoords(trace, axLetter) {\n    var posLetter = getBoxPosLetter(trace);\n    var isBox = traceIs(trace, 'box-violin');\n    var isCandlestick = traceIs(trace._fullInput || {}, 'candlestick');\n\n    return (\n        isBox &&\n        !isCandlestick &&\n        axLetter === posLetter &&\n        trace[posLetter] === undefined &&\n        trace[posLetter + '0'] === undefined\n    );\n}\n","'use strict';\n\nvar Registry = require('../registry');\nvar Lib = require('../lib');\n\n/*\n * Create or update an observer. This function is designed to be\n * idempotent so that it can be called over and over as the component\n * updates, and will attach and detach listeners as needed.\n *\n * @param {optional object} container\n *      An object on which the observer is stored. This is the mechanism\n *      by which it is idempotent. If it already exists, another won't be\n *      added. Each time it's called, the value lookup table is updated.\n * @param {array} commandList\n *      An array of commands, following either `buttons` of `updatemenus`\n *      or `steps` of `sliders`.\n * @param {function} onchange\n *      A listener called when the value is changed. Receives data object\n *      with information about the new state.\n */\nexports.manageCommandObserver = function(gd, container, commandList, onchange) {\n    var ret = {};\n    var enabled = true;\n\n    if(container && container._commandObserver) {\n        ret = container._commandObserver;\n    }\n\n    if(!ret.cache) {\n        ret.cache = {};\n    }\n\n    // Either create or just recompute this:\n    ret.lookupTable = {};\n\n    var binding = exports.hasSimpleAPICommandBindings(gd, commandList, ret.lookupTable);\n\n    if(container && container._commandObserver) {\n        if(!binding) {\n            // If container exists and there are no longer any bindings,\n            // remove existing:\n            if(container._commandObserver.remove) {\n                container._commandObserver.remove();\n                container._commandObserver = null;\n                return ret;\n            }\n        } else {\n            // If container exists and there *are* bindings, then the lookup\n            // table should have been updated and check is already attached,\n            // so there's nothing to be done:\n            return ret;\n        }\n    }\n\n    // Determine whether there's anything to do for this binding:\n\n    if(binding) {\n        // Build the cache:\n        bindingValueHasChanged(gd, binding, ret.cache);\n\n        ret.check = function check() {\n            if(!enabled) return;\n\n            var update = bindingValueHasChanged(gd, binding, ret.cache);\n\n            if(update.changed && onchange) {\n                // Disable checks for the duration of this command in order to avoid\n                // infinite loops:\n                if(ret.lookupTable[update.value] !== undefined) {\n                    ret.disable();\n                    Promise.resolve(onchange({\n                        value: update.value,\n                        type: binding.type,\n                        prop: binding.prop,\n                        traces: binding.traces,\n                        index: ret.lookupTable[update.value]\n                    })).then(ret.enable, ret.enable);\n                }\n            }\n\n            return update.changed;\n        };\n\n        var checkEvents = [\n            'plotly_relayout',\n            'plotly_redraw',\n            'plotly_restyle',\n            'plotly_update',\n            'plotly_animatingframe',\n            'plotly_afterplot'\n        ];\n\n        for(var i = 0; i < checkEvents.length; i++) {\n            gd._internalOn(checkEvents[i], ret.check);\n        }\n\n        ret.remove = function() {\n            for(var i = 0; i < checkEvents.length; i++) {\n                gd._removeInternalListener(checkEvents[i], ret.check);\n            }\n        };\n    } else {\n        // TODO: It'd be really neat to actually give a *reason* for this, but at least a warning\n        // is a start\n        Lib.log('Unable to automatically bind plot updates to API command');\n\n        ret.lookupTable = {};\n        ret.remove = function() {};\n    }\n\n    ret.disable = function disable() {\n        enabled = false;\n    };\n\n    ret.enable = function enable() {\n        enabled = true;\n    };\n\n    if(container) {\n        container._commandObserver = ret;\n    }\n\n    return ret;\n};\n\n/*\n * This function checks to see if an array of objects containing\n * method and args properties is compatible with automatic two-way\n * binding. The criteria right now are that\n *\n *   1. multiple traces may be affected\n *   2. only one property may be affected\n *   3. the same property must be affected by all commands\n */\nexports.hasSimpleAPICommandBindings = function(gd, commandList, bindingsByValue) {\n    var i;\n    var n = commandList.length;\n\n    var refBinding;\n\n    for(i = 0; i < n; i++) {\n        var binding;\n        var command = commandList[i];\n        var method = command.method;\n        var args = command.args;\n\n        if(!Array.isArray(args)) args = [];\n\n        // If any command has no method, refuse to bind:\n        if(!method) {\n            return false;\n        }\n        var bindings = exports.computeAPICommandBindings(gd, method, args);\n\n        // Right now, handle one and *only* one property being set:\n        if(bindings.length !== 1) {\n            return false;\n        }\n\n        if(!refBinding) {\n            refBinding = bindings[0];\n            if(Array.isArray(refBinding.traces)) {\n                refBinding.traces.sort();\n            }\n        } else {\n            binding = bindings[0];\n            if(binding.type !== refBinding.type) {\n                return false;\n            }\n            if(binding.prop !== refBinding.prop) {\n                return false;\n            }\n            if(Array.isArray(refBinding.traces)) {\n                if(Array.isArray(binding.traces)) {\n                    binding.traces.sort();\n                    for(var j = 0; j < refBinding.traces.length; j++) {\n                        if(refBinding.traces[j] !== binding.traces[j]) {\n                            return false;\n                        }\n                    }\n                } else {\n                    return false;\n                }\n            } else {\n                if(binding.prop !== refBinding.prop) {\n                    return false;\n                }\n            }\n        }\n\n        binding = bindings[0];\n        var value = binding.value;\n        if(Array.isArray(value)) {\n            if(value.length === 1) {\n                value = value[0];\n            } else {\n                return false;\n            }\n        }\n        if(bindingsByValue) {\n            bindingsByValue[value] = i;\n        }\n    }\n\n    return refBinding;\n};\n\nfunction bindingValueHasChanged(gd, binding, cache) {\n    var container, value, obj;\n    var changed = false;\n\n    if(binding.type === 'data') {\n        // If it's data, we need to get a trace. Based on the limited scope\n        // of what we cover, we can just take the first trace from the list,\n        // or otherwise just the first trace:\n        container = gd._fullData[binding.traces !== null ? binding.traces[0] : 0];\n    } else if(binding.type === 'layout') {\n        container = gd._fullLayout;\n    } else {\n        return false;\n    }\n\n    value = Lib.nestedProperty(container, binding.prop).get();\n\n    obj = cache[binding.type] = cache[binding.type] || {};\n\n    if(obj.hasOwnProperty(binding.prop)) {\n        if(obj[binding.prop] !== value) {\n            changed = true;\n        }\n    }\n\n    obj[binding.prop] = value;\n\n    return {\n        changed: changed,\n        value: value\n    };\n}\n\n/*\n * Execute an API command. There's really not much to this; it just provides\n * a common hook so that implementations don't need to be synchronized across\n * multiple components with the ability to invoke API commands.\n *\n * @param {string} method\n *      The name of the plotly command to execute. Must be one of 'animate',\n *      'restyle', 'relayout', 'update'.\n * @param {array} args\n *      A list of arguments passed to the API command\n */\nexports.executeAPICommand = function(gd, method, args) {\n    if(method === 'skip') return Promise.resolve();\n\n    var _method = Registry.apiMethodRegistry[method];\n    var allArgs = [gd];\n    if(!Array.isArray(args)) args = [];\n\n    for(var i = 0; i < args.length; i++) {\n        allArgs.push(args[i]);\n    }\n\n    return _method.apply(null, allArgs).catch(function(err) {\n        Lib.warn('API call to Plotly.' + method + ' rejected.', err);\n        return Promise.reject(err);\n    });\n};\n\nexports.computeAPICommandBindings = function(gd, method, args) {\n    var bindings;\n\n    if(!Array.isArray(args)) args = [];\n\n    switch(method) {\n        case 'restyle':\n            bindings = computeDataBindings(gd, args);\n            break;\n        case 'relayout':\n            bindings = computeLayoutBindings(gd, args);\n            break;\n        case 'update':\n            bindings = computeDataBindings(gd, [args[0], args[2]])\n                .concat(computeLayoutBindings(gd, [args[1]]));\n            break;\n        case 'animate':\n            bindings = computeAnimateBindings(gd, args);\n            break;\n        default:\n            // This is the case where intelligent logic about what affects\n            // this command is not implemented. It causes no ill effects.\n            // For example, addFrames simply won't bind to a control component.\n            bindings = [];\n    }\n    return bindings;\n};\n\nfunction computeAnimateBindings(gd, args) {\n    // We'll assume that the only relevant modification an animation\n    // makes that's meaningfully tracked is the frame:\n    if(Array.isArray(args[0]) && args[0].length === 1 && ['string', 'number'].indexOf(typeof args[0][0]) !== -1) {\n        return [{type: 'layout', prop: '_currentFrame', value: args[0][0].toString()}];\n    } else {\n        return [];\n    }\n}\n\nfunction computeLayoutBindings(gd, args) {\n    var bindings = [];\n\n    var astr = args[0];\n    var aobj = {};\n    if(typeof astr === 'string') {\n        aobj[astr] = args[1];\n    } else if(Lib.isPlainObject(astr)) {\n        aobj = astr;\n    } else {\n        return bindings;\n    }\n\n    crawl(aobj, function(path, attrName, attr) {\n        bindings.push({type: 'layout', prop: path, value: attr});\n    }, '', 0);\n\n    return bindings;\n}\n\nfunction computeDataBindings(gd, args) {\n    var traces, astr, val, aobj;\n    var bindings = [];\n\n    // Logic copied from Plotly.restyle:\n    astr = args[0];\n    val = args[1];\n    traces = args[2];\n    aobj = {};\n    if(typeof astr === 'string') {\n        aobj[astr] = val;\n    } else if(Lib.isPlainObject(astr)) {\n        // the 3-arg form\n        aobj = astr;\n\n        if(traces === undefined) {\n            traces = val;\n        }\n    } else {\n        return bindings;\n    }\n\n    if(traces === undefined) {\n        // Explicitly assign this to null instead of undefined:\n        traces = null;\n    }\n\n    crawl(aobj, function(path, attrName, _attr) {\n        var thisTraces;\n        var attr;\n\n        if(Array.isArray(_attr)) {\n            attr = _attr.slice();\n\n            var nAttr = Math.min(attr.length, gd.data.length);\n            if(traces) {\n                nAttr = Math.min(nAttr, traces.length);\n            }\n            thisTraces = [];\n            for(var j = 0; j < nAttr; j++) {\n                thisTraces[j] = traces ? traces[j] : j;\n            }\n        } else {\n            attr = _attr;\n            thisTraces = traces ? traces.slice() : null;\n        }\n\n        // Convert [7] to just 7 when traces is null:\n        if(thisTraces === null) {\n            if(Array.isArray(attr)) {\n                attr = attr[0];\n            }\n        } else if(Array.isArray(thisTraces)) {\n            if(!Array.isArray(attr)) {\n                var tmp = attr;\n                attr = [];\n                for(var i = 0; i < thisTraces.length; i++) {\n                    attr[i] = tmp;\n                }\n            }\n            attr.length = Math.min(thisTraces.length, attr.length);\n        }\n\n        bindings.push({\n            type: 'data',\n            prop: path,\n            traces: thisTraces,\n            value: attr\n        });\n    }, '', 0);\n\n    return bindings;\n}\n\nfunction crawl(attrs, callback, path, depth) {\n    Object.keys(attrs).forEach(function(attrName) {\n        var attr = attrs[attrName];\n\n        if(attrName[0] === '_') return;\n\n        var thisPath = path + (depth > 0 ? '.' : '') + attrName;\n\n        if(Lib.isPlainObject(attr)) {\n            crawl(attr, callback, thisPath, depth + 1);\n        } else {\n            // Only execute the callback on leaf nodes:\n            callback(thisPath, attrName, attr);\n        }\n    });\n}\n","'use strict';\n\nvar extendFlat = require('../lib/extend').extendFlat;\n\n/**\n * Make a xy domain attribute group\n *\n * @param {object} opts\n *   @param {string}\n *     opts.name: name to be inserted in the default description\n *   @param {boolean}\n *     opts.trace: set to true for trace containers\n *   @param {string}\n *     opts.editType: editType for all pieces\n *   @param {boolean}\n *     opts.noGridCell: set to true to omit `row` and `column`\n *\n * @param {object} extra\n *   @param {string}\n *     extra.description: extra description. N.B we use\n *     a separate extra container to make it compatible with\n *     the compress_attributes transform.\n *\n * @return {object} attributes object containing {x,y} as specified\n */\nexports.attributes = function(opts, extra) {\n    opts = opts || {};\n    extra = extra || {};\n\n    var base = {\n        valType: 'info_array',\n        editType: opts.editType,\n        items: [\n            {valType: 'number', min: 0, max: 1, editType: opts.editType},\n            {valType: 'number', min: 0, max: 1, editType: opts.editType}\n        ],\n        dflt: [0, 1]\n    };\n\n    var namePart = opts.name ? opts.name + ' ' : '';\n    var contPart = opts.trace ? 'trace ' : 'subplot ';\n    var descPart = extra.description ? ' ' + extra.description : '';\n\n    var out = {\n        x: extendFlat({}, base, {\n            description: [\n                'Sets the horizontal domain of this ',\n                namePart,\n                contPart,\n                '(in plot fraction).',\n                descPart\n            ].join('')\n        }),\n        y: extendFlat({}, base, {\n            description: [\n                'Sets the vertical domain of this ',\n                namePart,\n                contPart,\n                '(in plot fraction).',\n                descPart\n            ].join('')\n        }),\n        editType: opts.editType\n    };\n\n    if(!opts.noGridCell) {\n        out.row = {\n            valType: 'integer',\n            min: 0,\n            dflt: 0,\n            editType: opts.editType,\n            description: [\n                'If there is a layout grid, use the domain ',\n                'for this row in the grid for this ',\n                namePart,\n                contPart,\n                '.',\n                descPart\n            ].join('')\n        };\n        out.column = {\n            valType: 'integer',\n            min: 0,\n            dflt: 0,\n            editType: opts.editType,\n            description: [\n                'If there is a layout grid, use the domain ',\n                'for this column in the grid for this ',\n                namePart,\n                contPart,\n                '.',\n                descPart\n            ].join('')\n        };\n    }\n\n    return out;\n};\n\nexports.defaults = function(containerOut, layout, coerce, dfltDomains) {\n    var dfltX = (dfltDomains && dfltDomains.x) || [0, 1];\n    var dfltY = (dfltDomains && dfltDomains.y) || [0, 1];\n\n    var grid = layout.grid;\n    if(grid) {\n        var column = coerce('domain.column');\n        if(column !== undefined) {\n            if(column < grid.columns) dfltX = grid._domains.x[column];\n            else delete containerOut.domain.column;\n        }\n\n        var row = coerce('domain.row');\n        if(row !== undefined) {\n            if(row < grid.rows) dfltY = grid._domains.y[row];\n            else delete containerOut.domain.row;\n        }\n    }\n\n    var x = coerce('domain.x', dfltX);\n    var y = coerce('domain.y', dfltY);\n\n    // don't accept bad input data\n    if(!(x[0] < x[1])) containerOut.domain.x = dfltX.slice();\n    if(!(y[0] < y[1])) containerOut.domain.y = dfltY.slice();\n};\n","'use strict';\n\n/*\n * make a font attribute group\n *\n * @param {object} opts\n *   @param {string}\n *     opts.description: where & how this font is used\n *   @param {optional bool} arrayOk:\n *     should each part (family, size, color) be arrayOk? default false.\n *   @param {string} editType:\n *     the editType for all pieces of this font\n *   @param {optional string} colorEditType:\n *     a separate editType just for color\n *\n * @return {object} attributes object containing {family, size, color} as specified\n */\nmodule.exports = function(opts) {\n    var editType = opts.editType;\n    var colorEditType = opts.colorEditType;\n    if(colorEditType === undefined) colorEditType = editType;\n    var attrs = {\n        family: {\n            valType: 'string',\n            noBlank: true,\n            strict: true,\n            editType: editType,\n            description: [\n                'HTML font family - the typeface that will be applied by the web browser.',\n                'The web browser will only be able to apply a font if it is available on the system',\n                'which it operates. Provide multiple font families, separated by commas, to indicate',\n                'the preference in which to apply fonts if they aren\\'t available on the system.',\n                'The Chart Studio Cloud (at https://chart-studio.plotly.com or on-premise) generates images on a server,',\n                'where only a select number of',\n                'fonts are installed and supported.',\n                'These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*,',\n                '*Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*,',\n                '*PT Sans Narrow*, *Raleway*, *Times New Roman*.'\n            ].join(' ')\n        },\n        size: {\n            valType: 'number',\n            min: 1,\n            editType: editType\n        },\n        color: {\n            valType: 'color',\n            editType: colorEditType\n        },\n        editType: editType,\n        // blank strings so compress_attributes can remove\n        // TODO - that's uber hacky... better solution?\n        description: '' + (opts.description || '') + ''\n    };\n\n    if(opts.autoSize) attrs.size.dflt = 'auto';\n    if(opts.autoColor) attrs.color.dflt = 'auto';\n\n    if(opts.arrayOk) {\n        attrs.family.arrayOk = true;\n        attrs.size.arrayOk = true;\n        attrs.color.arrayOk = true;\n    }\n\n    return attrs;\n};\n","'use strict';\n\nmodule.exports = {\n    _isLinkedToArray: 'frames_entry',\n\n    group: {\n        valType: 'string',\n        description: [\n            'An identifier that specifies the group to which the frame belongs,',\n            'used by animate to select a subset of frames.'\n        ].join(' ')\n    },\n    name: {\n        valType: 'string',\n        description: 'A label by which to identify the frame'\n    },\n    traces: {\n        valType: 'any',\n        description: [\n            'A list of trace indices that identify the respective traces in the',\n            'data attribute'\n        ].join(' ')\n    },\n    baseframe: {\n        valType: 'string',\n        description: [\n            'The name of the frame into which this frame\\'s properties are merged',\n            'before applying. This is used to unify properties and avoid needing',\n            'to specify the same values for the same properties in multiple frames.'\n        ].join(' ')\n    },\n    data: {\n        valType: 'any',\n        description: [\n            'A list of traces this frame modifies. The format is identical to the',\n            'normal trace definition.'\n        ].join(' ')\n    },\n    layout: {\n        valType: 'any',\n        description: [\n            'Layout properties which this frame modifies. The format is identical',\n            'to the normal layout definition.'\n        ].join(' ')\n    }\n};\n"],"names":["module","exports","mode","valType","dflt","values","description","join","direction","fromcurrent","frame","duration","min","redraw","transition","editType","easing","ordering","Lib","require","Template","parentObjIn","parentObjOut","opts","i","itemOut","name","inclusionAttr","previousContOut","contIn","isArrayOrTypedArray","contOut","templater","arrayTemplater","length","itemIn","isPlainObject","newItem","_index","handleItemDefaults","push","defaultItems","len","Math","relinkPrivateKeys","fontAttrs","fxAttrs","type","_noTemplating","visible","showlegend","legend","legendgroup","legendgrouptitle","text","font","legendrank","legendwidth","opacity","max","uid","anim","ids","customdata","meta","arrayOk","selectedpoints","hoverinfo","flags","extras","hoverlabel","stream","token","noBlank","strict","maxpoints","transforms","_isLinkedToArray","uirevision","isNumeric","dateTime2ms","incrementMonth","ONEAVGMONTH","trace","ax","axLetter","vals","alignment","mPeriod","period","charAt","n","substring","round","calendar","isStart","isEnd","period0","base","newVals","starts","ends","nEstimated","startTime","endTime","v","xaxis","yaxis","d3","FP_SAFE","Registry","Drawing","axIds","getFromId","isLinked","getAutoRange","gd","j","newRange","fullLayout","_fullLayout","getPadMin","makePadFn","getPadMax","extremes","concatExtremes","minArray","maxArray","simpleMap","range","r2l","minmin","val","maxmax","autorange","axReverse","rng","minpt","maxpt","minbest","maxbest","dp","dv","rangeMode","rangemode","toZero","nonNegative","axLen","_length","minSpan","mbest","calcBreaksLength","nopad","lower","upper","maxPad","reduce","prev","pt","rangeEnd","applyAutorangeOptions","limitRange","reverse","l2r","Number","v0","v1","lBreaks","rangebreaks","rangebreaksOut","locateBreaks","brk","extrappad","anchorAxis","_anchorAxis","ticklabelposition","indexOf","isReversed","zero","_id","pad","isX","subplot","_plots","plotinfo","side","_vals","rad","deg2rad","_tickAngles","cosA","abs","cos","sinA","sin","bb","cls","_selections","each","d","thisLabel","select","this","empty","bBox","node","w","TEXTPAD","width","h","height","ticks","ticklen","padInsideLabelsOnAnchorAxis","constrain","_inputDomain","domain","extrapad","doAutoRange","presetRange","setScale","slice","_r","_rl","axIn","_input","edits","_attr","call","layout","_preGUI","anchorAx","rangeslider","axeRangeOpts","_name","extendFlat","findExtremes","data","_m","di","dmin","dmax","ppadiplus","ppadiminus","vmin","vmax","padded","tozero","isLog","hasArrayOption","vpadLinearized","makePadAccessor","item","Array","isArray","ppadplus","ppadminus","ppad","vpadplus","vpad","vpadminus","Infinity","collapseOpts","addItem","c2l","goodNumber","collapseMinArray","collapseMaxArray","iMax","noMatch","axId","fullData","_fullData","_concat","cont","indices","_extremes","_traceIndices","annotations","_annIndices","shapes","_shapeIndices","_matchGroup","axId2","ax2","extremes2","lenRatio","array","newVal","newPad","collapseArray","lessOrEqual","greaterOrEqual","atLeastAsExtreme","includeThis","splice","clipAtZero","hasValidMinAndMax","undefined","d2l","autorangeoptions","include","lMin","lMax","minallowed","maxallowed","clipmin","clipmax","applyAutorangeMinOptions","applyAutorangeMaxOptions","coerce","minRange","maxRange","Plots","strTranslate","svgTextUtils","Titles","Color","axAttrs","cleanTicks","constants","ONEMAXYEAR","ONEAVGYEAR","ONEMINYEAR","ONEMAXQUARTER","ONEAVGQUARTER","ONEMINQUARTER","ONEMAXMONTH","ONEMINMONTH","ONEWEEK","ONEDAY","HALFDAY","ONEHOUR","ONEMIN","ONESEC","MINUS_SIGN","BADNUM","ZERO_PATH","K","GRID_PATH","L","MINORGRID_PATH","TICK_PATH","TICK_TEXT","MARGIN_MAPPING","right","left","top","bottom","alignmentConstants","MID_SHIFT","CAP_SHIFT","LINE_SPACING","OPPOSITE_SIDE","axes","setConvert","autoType","axisIds","idSort","id2name","name2id","cleanId","list","listIds","getFromTrace","expandRange","delta","coerceRef","containerIn","containerOut","attr","extraOption","axlist","_subplots","refAttr","attrDef","concat","map","x","getRefType","ar","test","coercePosition","axRef","cleanPos","pos","ensureNumber","fraction2r","cleanPosition","redrawComponents","_redrawOneComp","moduleName","methodName","stashName","shortCircuit","method","getComponentMethod","stash","ind","getDataConversions","target","targetArray","d2cTarget","autotypenumbers","_categories","d2c","c2d","toString","toNum","String","isMultiple","bigger","smaller","isClose","a","b","nMonths","dtick","filterRangeBreaks","ticksOut","filter","maskBreaks","syncTicks","baseAxis","_mainAxis","noTick","l2p","vali","p2l","obj","tickText","minor","arrayTicks","majorOnly","exRng","tickMin","tickMax","tickVal2l","d2l_noadd","pow","floor","isMinor","tickvals","ticktext","tickTextObj","getDataToCoordFunc","counterLetter","id","minDtick","newDiff","newFirst","allow","_minDtick","_forceTick0","saveRangeInitial","overwrite","axList","hasOneAxisChanged","isNew","_rangeInitial0","_rangeInitial1","hasChanged","_autorangeInitial","saveShowSpikeInitial","allSpikesEnabled","_showSpikeInitial","showspikes","_showspikes","_cartesianSpikesEnabled","autoBin","nbins","is2d","size","dummyAx","dataMin","aggNums","dataMax","start","end","_dataSpan","c2r","tick0","size0","distinctData","distinctVals","msexp","log","minDiff","LN10","minSize","roundUp","stdev","autoTicks","binEnd","finalSize","binStart","tickIncrement","tickFirst","edgecount","midcount","intcount","blankCount","nearEdge","dataCount","binshift","autoShiftNumericBins","stats","findExactDates","threshold","exactDays","numMonths","substr","exactYears","exactMonths","nextBinStart","autoShiftMonthBins","prepMinorTicks","mockAx","mockMinorRange","hasMajor","_tmin","tick2","rl","_isMinor","prepTicks","numericMajor","numericMinor","majorNum","minorNum","nticks","_tick0Init","tickmode","minPx","nt","tickfont","bigFont","_roughDTick","ticklabelmode","definedDelta","mDate","isMDate","tickformat","getTickFormat","noDtick","_dtickInit","_dowTick0","_rawTick0","_definedDelta","adjustPeriodDelta","autoTickRound","calcTicks","lastVisibleHead","ticklabelstep","isPeriod","axrev","maxTicks","minorTicks","tickVals","minorTickVals","hasMinor","showgrid","major","startTick","endTick","numDtick","isDLog","x0","majorId","_dTick","prevX","moveOutsideBreak","value","simpleLabel","skipLabel","majorValues","k","T","found","q","inBetween","A","B","actualDelta","periodLength","endPeriod","c","r","drop","periodX","positionPeriodTicks","flip","fontSize","prevL","NaN","l","c2p","isAngular","pop","_tmax","_prevDateHead","_inCalcTicks","t","p","hideLabel","tick","_minor","_value","roundBase10","roundBase24","roundBase60","roundDays","roundLog1","roundLog2","roundAngles","roundDTick","roughDTick","roundingSet","_tickexponent","_tickround","tick0ms","tick0str","replace","tick0len","tick1len","r2d","maxend","rangeexp","minexponent","isSIFormat","exponentformat","beyondSI","tf","dx","dy","family","fontColor","color","getBase","dateTick0","roughX2","_hasDayOfWeekBreaks","ceil","olddtick","axSign","increment","tType","dtSigned","tickset","x2","frac","mod","sRound","r0","tmin","dtNum","t1","mult","newDTick","cnt","t0","error","hover","noSuffixPrefix","out","arrayMode","extraPrecision","axType","_lBreaks","isHidden","showAttr","firstOrLast","first","last","hideexp","showexponent","tr","fmt","hoverformat","y","m","M","S","headStr","dateStr","formatDate","_dateFormat","_extraFormat","splitIndex","isInside","insideTicklabelposition","_trueSide","dtChar0","numFormat","absP","exponentFormat","firstChar","formatLog","tt","formatCategory","cats","tt2","text2","formatMultiCategory","thetaunit","num","almostEq","findGCD","findPrecision","e","precision","number","gcd","num2frac","isNeg","formatAngle","formatLinear","tickprefix","showtickprefix","ticksuffix","showticksuffix","labelalias","hasOwnProperty","tickson","showdividers","inbounds","xbnd","hoverLabelText","val2","logOffScale","tx","SIPREFIXES","exponent","fmtoverride","tickRound","separatethousands","ah","_numFormat","signedExponent","numSeparate","_separators","filterPush","automargin","keepMargin","Object","keys","nextKey","forEach","key","getSecondaryLabelVals","lookup","interp","getPosX","tickDataFn","axInfo","approxTitleDepth","title","extraLines","match","BR_TAG_ALL","clipEnds","selectTickLabel","gTick","s","mj","axAutoMarginID","axMirrorAutoMarginID","rangeSliderAutoMarginID","mergeAxisGroups","intoSet","fromSet","swapAxisGroup","xIds","yIds","xFullAxes","yFullAxes","allAxKeys","noSwapAttrs","numericTypes","keyi","xVal","yVal","allEqual","coerceLinearX","coerceLinearY","xVali","yVali","swapAxisAttrs","_dfltTitle","ann","xref","yref","swapAttrs","dfltTitle","np","nestedProperty","get","set","_rangebreaks","hideCounterAxisInsideTickLabels","_hideCounterAxisInsideTickLabels","incrementShift","shiftVal","axShifts","normalize","shiftValAdj","overlay","anchor","overlaying","tickstop","stopi","convertToMs","compareLogTicks","priority","leftPriority","rightPriority","isProperStop","convert","convertFn","leftDtick","rightDtick","isProperLogStop","isLeftDtickNull","isRightDtickNull","isDtickInRangeLeft","isDtickInRangeRight","tickformatstops","enabled","dtickrange","getSubplots","subplotObj","allSubplots","cartesian","gl2d","findSubplotsWithAxis","sort","aParts","split","bParts","subplots","axMatch","RegExp","subplotsWithAx","sp","makeClipPaths","_hasOnlyLargeSploms","fullWidth","_offset","fullHeight","xaList","yaList","clipList","axClips","_clips","selectAll","enter","append","classed","_uid","exit","remove","draw","arg","_paper","xa","ya","xaxislayer","yaxislayer","minorGridlayer","gridlayer","zerolinelayer","_infolayer","overlayingShiftedAx","autoshift","overlayingIndex","findIndex","axis","unshift","shift","false","syncOrAsync","axDone","drawOne","_shiftPusher","_fullDepth","mainPlotinfo","_mainSubplot","selfPush","linewidth","skipTitle","_shift","setShiftVal","mainAxLayer","mainLinePosition","_mainLinePosition","mainLinePositionShift","mainMirrorPosition","_mainMirrorPosition","mirror","_prevTickAngles","_depth","llbboxes","valsClipped","transTickFn","makeTransTickFn","transTickLabelFn","makeTransTickLabelFn","insideTicks","outsideTicks","boundaryVals","_push","bndIndex","xb","getBoundaryVals","tickPath","gridVals","_gridVals","dividerVals","current","reversed","getDividerVals","_subplotsWith","finishedGrids","counterAxis","mainCounterID","gridPath","drawGrid","layer","minorLayer","path","transFn","drawZeroLine","majorTickSigns","getTickSigns","minorTickSigns","mirrorMajorTickPath","mirrorMinorTickPath","fullMajorTickPath","fullMinorTickPath","majorTickPath","makeTickPath","minorTickPath","dividerLookup","drawTicks","tickSubplots","_linepositions","linepositions","p0","p1","spTickPath","seq","drawLabels","labelFns","makeLabelFns","bboxKey","standoff","getLabelLevelBbox","repositionOnUpdate","secondary","dividers","insert","stroke","dividercolor","style","crispRound","dividerwidth","drawDividers","hasRangeSlider","titleStandoff","offsetBase","showticklabels","transform","avoid","getPxPosition","rotate","offset","tickLabels","selection","parentNode","translation","getTranslate","offsetLeft","offsetTop","_titleStandoff","propContainer","propName","placeholder","attributes","drawTitle","llbbox","mirrorPush","rangeSliderPush","sMirror","outsideTickLen","axDepth","titleDepth","_titleScoot","domainIndices","rExtra","xr","lExtra","xl","bExtra","yb","tExtra","yt","position","_counterDomainMin","_counterDomainMax","autoMargin","suffix","calcLabelLevelBbox","sideOpposite","main","uv","has","str","isTop","isLeft","isRight","isBottom","isAligned","u","tickwidth","getTickLabelUV","sgn","angle","insideTickLabels","labelsOverTicks","labelStandoff","labelShift","tickLen","showline","y0","ff","flipIt","endSide","xQ","tickangle","xFn","yFn","anchorFn","heightFn","ang","rA","crisp","tickcolor","minorVals","majorVals","counterAx","shouldShowZeroLine","isArrayMode","xi","_gw","gridwidth","wMinor","majorLayer","grid","gridcolor","dashStyle","griddash","show","zl","da","db","zerolinecolor","defaultLine","zerolinewidth","tickAngle","prevAngle","labelsReady","positionLabels","mathjaxGroup","nLines","lineCount","lineHeight","anchorHeight","thisText","_adjustTickLabelsOverflow","mjShift","newPromise","_promises","positionText","convertToTspans","then","ticklabeloverflow","hideOverflow","visibleLabelMin","visibleLabelMax","adjust","partialOpts","anchoredAxes","idx","isPeriodLabel","autoangle","Promise","all","_redrawFromAutoMarginCount","autotickangles","maxFontSize","lbbArray","maxLines","vLen","tickSpacing","adjacent","opposite","maxCos","sqrt","autoTickAnglesRadians","degrees","PI","angleRadians","find","currentMax","nextAngle","newAngle","bBoxIntersect","gap","lbb","computeTickLabelBoundingBoxes","labelsMaxW","labelsMaxH","insiderange","_insideTickLabelsUpdaterange","BBs","move","index","otherIndex","anchorAxRange","d2p","_tempNewRange","q0","q1","dir","dist","p2d","done","gs","_size","zeroline","mainCounterAxis","zeroPosition","lineNearZero","tolerance","closeEnough","pos2","linePositions","mainplotinfo","overlays","counterLetterAxes","counterAxis2","anyCounterAxLineAtZero","traceIs","orientation","fill","hasBarsOrFill","allowAutoMargin","swap","traces","axGroups","groups","groupsi","yi","groupj","group0","makeAxisGroups","isDateTime","cleanNumber","hasTypeNumber","convertNumeric","getIncrement","noMultiCategory","multiCategory","inc","dats","nums","seen","f","ai","stri","moreDates","category","linearOK","handleArrayContainerDefaults","layoutAttributes","handleTickValueDefaults","handleTickMarkDefaults","handleTickLabelDefaults","handlePrefixSuffixDefaults","handleCategoryOrderDefaults","handleLineGridDefaults","handleRangeDefaults","DAY_OF_WEEK","HOUR","rangebreaksDefaults","bnds","dfltPattern","indexOfDay","pattern","bounds","options","layoutOut","letter","splomStash","visibleDflt","axTemplate","_template","handleCalendarDefaults","noTicklabelmode","noTicklabelposition","noTicklabeloverflow","noHover","dfltColor","dfltFontColor","label","coerceFont","newContainer","keepIsMinor","bgColor","showGrid","ticksonDflt","isMultiCategory","noTickson","_has","warn","dayStrToNum","sun","mon","tue","wed","thu","fri","sat","toLowerCase","docs","FORMAT_LINK","DATE_FORMAT_LINK","descriptionOnlyNumbers","descriptionWithDates","axisHoverFormat","noDates","isFound","AX_ID_PATTERN","axNum","AX_NAME_PATTERN","domainId","domainTest","only2d","idList","idi","sceneIds3D","gl3d","scene","zaxis","subplotLists","fullTrace","id1","id2","letter1","letter2","ref2id","_axisMatchGroups","_axisConstraintGroups","isTypedArraySpec","orderDefault","arrayIn","categoryarray","isValidArray","order","categoryorder","_initialCategories","axData","dataAttr","findCategories","isDate","isCat","dtickDflt","prefix","dtickNum","cleanDate","counterRegex","idRegex","attrRegex","xAxisMatch","yAxisMatch","SUBPLOT_PATTERN","HOUR_PATTERN","WEEKDAY_PATTERN","MINDRAG","MINZOOM","DRAGGERSIZE","REDRAWDELAY","DFLTRANGEX","DFLTRANGEY","traceLayerClasses","clipOnAxisFalseQuery","layerValue2layerClass","scaleZoom","ALMOST_EQUAL","FROM_BL","handleOneAxDefaults","axOut","hasImage","constraintGroups","matchGroups","_splomAxes","thisID","_constraintGroup","constraintoward","thisType","linkableAxes","thisGroup","getConstraintGroup","linkableAxesNoLoops","matches","scaleanchor","canLink","scaleanchorDflt","updateConstraintGroups","matchedAx","matchRatio","extent","scaleratio","thatID","groupi","keyj","thisGroupIndex","thisGroupKeys","baseScale","multiplyScales","aLen","bLen","aPrefix","bPrefix","finalRatios","group","yRatio","pLen","updateDomain","factor","inputDomain","centerFraction","center","handleDefaults","layoutIn","axName","axHasImage","stashAttr","fixedrange","axName2","matchAttrs","hasRange","hasDayOfWeekBreaks","setAttrVal","baseAx","enforce","axisID","normScale","axisIDs","minScale","maxScale","matchScale","normScales","hasAnyDomainConstraint","_inputRange","_constraintShrinkable","domainShrunk","rangeShrunk","rl0","rl1","rangeCenter","rangeMin","rangeMax","halfRange","outerMin","outerMax","getAxisGroup","clean","isConstrained","numberFormat","tinycolor","supportsPassive","Fx","Axes","setCursor","dragElement","helpers","selectingOrDrawing","freeMode","FROM_TL","clearGlCanvases","redrawReglTraces","prepSelect","clearOutline","selectOnClick","SHOWZOOMOUTTIP","makeDragger","nodeName","dragClass","cursor","dragger3","ensureSingle","draglayer","makeRectDragger","dragger","setRect","isDirectionActive","activeVal","zoomAxRanges","r0Fraction","r1Fraction","updates","linkedAxes","axi","isY","r0F","r1F","axRangeLinear0","axRangeLinearSpan","linkedR0Fraction","dragAxList","pix","dZoom","makeZoombox","zoomlayer","lum","xs","ys","path0","makeCorners","background","updateZoombox","zb","corners","box","dimmed","transitionZoombox","removeZoombox","showDoubleClickNotifier","_context","showTips","notifier","_","xyCorners","clen","calcLinks","xaHash","yaHash","exclude","xID","yID","xLinkID","yLinkID","isSubplotConstrained","xLinks","yLinks","xExclude","yExclude","xaHashLinked","xaxesLinked","yaHashLinked","yaxesLinked","xaxes","yaxes","attachWheelEventHandler","element","handler","wheelEventName","onwheel","_onwheel","removeEventListener","addEventListener","passive","onmousewheel","isAddedWheelEvent","hashValues","hash","makeDragBox","ns","ew","xa0","ya0","pw","ph","links","xActive","yActive","allFixedRanges","editX","editY","hasScatterGl","hasSplom","hasSVG","scaleX","scaleY","_zoomlayer","isMainDrag","singleEnd","recomputeAxisLists","spConstrained","nsew","dragmode","getDragCursor","onmousedown","pointerEvents","zoomMode","zoomDragged","dragOptions","clearAndResetSelect","clickFn","numClicks","evt","_activeShapeIndex","_deactivateShape","clickmode","doubleClick","click","attrStr","initialText","dig","initialVal","diff","getEndText","hAlign","vAlign","showAxisRangeEntryBoxes","makeEditable","immediate","paper_bgcolor","horizontalAlign","verticalAlign","on","d2r","zoomMove","dx0","dy0","_transitioningWithDuration","x1","y1","noZoom","r1","xCorners","yCorners","_dragged","computeZoomUpdates","emit","updateMatchedAxRange","zoomDone","dragTail","prepFn","startX","startY","dragModePrev","dragModeNow","_invScaleX","_invScaleY","shiftKey","ctrlKey","minDrag","moveFn","doneFn","dragBBox","getBoundingClientRect","_calcInverseTransform","transformedCoords","apply3DTransform","_invTransform","_hmpixcount","_hmlumcount","plot_bgcolor","getLuminance","zoomPrep","plotDrag","_redrag","dragDataNow","_dragdata","updateSubplots","init","scrollViewBox","redrawTimer","mainplot","_replotting","spDx","spDy","ticksAndAnnotations","xStart","yStart","dxySign","dxyFraction","dz","xSize","ySize","axArray","movedAx","newLinearizedEnd","otherEnd","newEnd","matchedAxes","constrainedAxes","activeAxIds","pushActiveAxIds","pushActiveAxIdsSynced","axisType","axListI","axListIType","doubleClickConfig","attrs","hasRangeInitial","autorangeInitial","previousPromises","viewBox","plotinfos","subplotsRegistry","splom","drag","_scene","xrng","yrng","update","xScaleFactor","yScaleFactor","xScaleFactor2","yScaleFactor2","clipDx","clipDy","editX2","editY2","getShift","scaleAndGetShift","getLinkedScaleFactor","plotDx","plotDy","clipRect","setTranslate","plot","setPointGroupScale","zoomScalePts","setTextPointsScale","zoomScaleTxt","hideOutsideRangePoints","clipOnAxisFalseTraces","scaleFactor","from","_scrollZoom","_enablescrollzoom","preventDefault","stopPropagation","clearTimeout","wheelDelta","deltaY","isFinite","zoom","exp","gbb","xfrac","clientX","yfrac","clientY","zoomWheelOneAxis","setTimeout","axRange","initInteractions","staticPlot","maindrag","onmousemove","_rehover","_hoversubplot","_lasthover","onmouseout","_dragging","unhover","showAxisDragHandles","hoverLayer","_hoverlayer","onclick","updateFx","_draggers","containerArrayName","Cartesian","cartesianList","hasCartesianOrGL2D","itemi","hasXref","hasYref","pushUnique","_basePlotModules","newAxis","getModuleCalcData","xmlnsNamespaces","ensureSingleAndAddDatum","parent","nodeType","className","datum","plotOne","cdSubplot","transitionOpts","makeOnCompleteCallback","_module","cdModuleAndOthers","cdModule","modules","_modules","layerData","zoomScaleQueryParts","categories","svg","layerName","plotMethod","zoomScale","layers","isRangePlot","sel","setClipUrl","layerClipId","getModule","_hasClipOnAxisFalse","makeSubplotLayer","plotgroup","xLayer","yLayer","hasOnlyLargeSploms","mainplotgroup","xId","yId","overlinesBelow","overaxesBelow","overplot","overlinesAbove","overaxesAbove","xlines","ylines","backLayer","shapelayer","imagelayer","purgeSubplotLayers","overlayIdsToRemove","removeSubplotExtras","overlayInfo","subplotId","_defs","idRoot","supplyLayoutDefaults","transitionAxes","finalizeSubplots","xList","yList","spSVG","spAll","allX","allY","parts","ki","calcdata","pcd","subplotInfo","cd","carpet","newFullData","newFullLayout","oldFullData","oldFullLayout","oldPlots","newPlots","oldSubplotList","hadGl","hasGl","destroy","oldAxIDs","oldAxId","hadCartesian","hasCartesian","_cartesianlayer","oldSubplotId","selector","drawFramework","subplotData","regulars","xa2","ya2","subplotIds","makeSubplotData","subplotLayers","rangePlot","toSVG","imageRoot","_glimages","root","canvas","imageData","toDataURL","xmlns","preserveAspectRatio","colorAttrs","dash","templatedArray","minorTickmode","impliedEdits","makeNticks","makeTicklen","makeTickwidth","lightLine","makeGridwidth","items","freeLength","dvalue","spikecolor","spikethickness","spikedash","spikemode","spikesnap","linecolor","_deprecated","autotick","titlefont","isUnifiedHover","handleHoverModeDefaults","basePlotLayoutAttributes","handleTypeDefaults","handleAxisDefaults","constraints","handlePositionDefaults","appendList","autotypenumbersDflt","ax2traces","xaMayHide","yaMayHide","xaMustDisplay","yaMustDisplay","yaMustNotReverse","yaMayReverse","outerTicks","noGrids","xaName","yaName","_cheater","xNames","yNames","axNames","plotBgColor","axLayoutIn","axLayoutOut","combine","newAxLayoutOut","_expandedIndex","_selectionIndices","_imgIndices","_counterAxes","coerce2","getCounterAxes","getOverlayableAxes","counterAxes","allAxisIds","missingMatchedAxisIdsLookup","missingMatchedAxisIds","addMissingMatchedAxis","matchesIn","hovermode","unifiedHover","reverseDflt","defaultOptions","noAutotickangles","unifiedSpike","overlayingAxis","overlayingAnchorDomain","overlayingAnchor","overlayableAxes","overlayingDomain","defaultOptions2","rangeSliderDefaults","rangeSelectorDefaults","anchoredAxis","colorMix","lineColor","lineWidth","showLine","gridColor","blend","lightFraction","toRgbString","gridWidth","gridDash","minorGridColor","minorGridWidth","minorGridDash","noZeroLine","zeroLineColor","zeroLineWidth","dfltAnchor","dfltDomain","dfltSide","dfltPosition","dfltShift","dfltAutomargin","_domains","_axisMap","_anchors","noneOrAll","getShowAttrDflt","tickSuffixDflt","showAttrDflt","handleAutorangeOptionsDefaults","noInsiderange","shouldAutorange","autorangeDflt","getAutorangeDflt","cleanRange","rangeLinear","utcFormat","ms2DateTime","numConstants","LOG_CLIP","fromLog","isValidCategory","toLog","clip","dt2ms","msUTC","ms","msecTenths","msRounded","Date","ms2dt","getCategoryName","setCategoryIndex","_categoriesMap","curLength","getCategoryIndex","getCategoryPosition","getRangePosition","_l2p","_p2l","px","_b","signAx","b2","_B","_m2","pmin","pmax","l2c","p2c","r2c","l2d","r2p","p2r","identity","r2c_just_indices","setupMultiCategory","traceIndices","minRowLength","ind0","ind1","r2fraction","rangeAttr","minL","maxL","_max","_min","_cleanRange","dfltRange","nullRange0","nullRange1","linCenter","MIN_MS","MAX_MS","usePrivateRange","sign","Error","b0","b1","vb","vDate","rangebreaksIn","_cachedPatterns","_cachedValues","sorterAsc","getUTCDay","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","addBreak","isNewBreak","brkj","bndDelta","step","t0Date","makeCalcdata","arrayOut","cal","isTypedArray","subarray","setMultiCategoryIndex","isValidRange","nullOk","isPtWithinRange","coord","_emptyCategories","clearCalc","categoriesMap","sortByInitialCategories","affectedTraces","locale","_d3locale","timeFormat","separators","showAttrs","every","contrast","tickformatstopDefaults","valueIn","valueOut","contColor","noTicklabelstep","noAng","tickFormat","noExp","cIn","cOut","lAttr","tickWidth","tickColor","decodeTypedArraySpec","readInput","_tick0","_dtick","_tickvals","onComplete","t2","raf","easeFn","ease","_transitionData","_interruptCallbacks","window","cancelAnimationFrame","aobj","edit","xr0","yr0","unsetSubplotTransform","transitionInterrupt","now","requestAnimationFrame","doFrame","tInterp","progress","updateSubplot","xr1","yr1","transitionComplete","resolve","clipId","traceGroups","xlen","ylen","dx1","dy1","fracDx","fracDy","getBoxPosLetter","isBoxWithoutPositionCoords","posLetter","isBox","isCandlestick","_fullInput","d0","getFirstNonEmptyTrace","calAttr","_hasPreCompStats","boxPositions","dim","dimensions","_axesDim","setAutoType","bindingValueHasChanged","binding","cache","container","changed","prop","computeLayoutBindings","args","bindings","astr","crawl","attrName","computeDataBindings","thisTraces","nAttr","tmp","callback","depth","thisPath","manageCommandObserver","commandList","onchange","ret","_commandObserver","lookupTable","hasSimpleAPICommandBindings","check","disable","enable","checkEvents","_internalOn","_removeInternalListener","bindingsByValue","refBinding","command","computeAPICommandBindings","executeAPICommand","_method","apiMethodRegistry","allArgs","apply","catch","err","reject","computeAnimateBindings","extra","namePart","contPart","descPart","noGridCell","row","column","dfltDomains","dfltX","dfltY","columns","rows","colorEditType","autoSize","autoColor","baseframe"],"sourceRoot":""}