{"version":3,"file":"static/js/3236.d2f79d7d.js","mappings":"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","sources":["../node_modules/plotly.js/src/core.js","../node_modules/plotly.js/src/fonts/ploticon.js","../node_modules/plotly.js/src/lib/anchor_utils.js","../node_modules/plotly.js/src/lib/angles.js","../node_modules/plotly.js/src/lib/array.js","../node_modules/plotly.js/src/lib/clean_number.js","../node_modules/plotly.js/src/lib/clear_gl_canvases.js","../node_modules/plotly.js/src/lib/clear_responsive.js","../node_modules/plotly.js/src/lib/coerce.js","../node_modules/plotly.js/src/lib/dates.js","../node_modules/plotly.js/src/lib/dom.js","../node_modules/plotly.js/src/lib/events.js","../node_modules/plotly.js/src/lib/extend.js","../node_modules/plotly.js/src/lib/filter_unique.js","../node_modules/plotly.js/src/lib/filter_visible.js","../node_modules/plotly.js/src/lib/geometry2d.js","../node_modules/plotly.js/src/lib/identity.js","../node_modules/plotly.js/src/lib/increment.js","../node_modules/plotly.js/src/lib/index.js","../node_modules/plotly.js/src/lib/is_plain_object.js","../node_modules/plotly.js/src/lib/keyed_container.js","../node_modules/plotly.js/src/lib/localize.js","../node_modules/plotly.js/src/lib/loggers.js","../node_modules/plotly.js/src/lib/make_trace_groups.js","../node_modules/plotly.js/src/lib/matrix.js","../node_modules/plotly.js/src/lib/mod.js"],"sourcesContent":["'use strict';\n\nexports.version = require('./version').version;\n\n// inject promise polyfill\nrequire('native-promise-only');\n\n// inject plot css\nrequire('../build/plotcss');\n\n// include registry module and expose register method\nvar Registry = require('./registry');\nvar register = exports.register = Registry.register;\n\n// expose plot api methods\nvar plotApi = require('./plot_api');\nvar methodNames = Object.keys(plotApi);\nfor(var i = 0; i < methodNames.length; i++) {\n    var name = methodNames[i];\n    // _ -> private API methods, but still registered for internal use\n    if(name.charAt(0) !== '_') exports[name] = plotApi[name];\n    register({\n        moduleType: 'apiMethod',\n        name: name,\n        fn: plotApi[name]\n    });\n}\n\n// scatter is the only trace included by default\nregister(require('./traces/scatter'));\n\n// register all registrable components modules\nregister([\n    require('./components/annotations'),\n    require('./components/annotations3d'),\n    require('./components/selections'),\n    require('./components/shapes'),\n    require('./components/images'),\n    require('./components/updatemenus'),\n    require('./components/sliders'),\n    require('./components/rangeslider'),\n    require('./components/rangeselector'),\n    require('./components/grid'),\n    require('./components/errorbars'),\n    require('./components/colorscale'),\n    require('./components/colorbar'),\n    require('./components/legend'), // legend needs to come after shape | legend defaults depends on shapes\n    require('./components/fx'), // fx needs to come after legend | unified hover defaults depends on legends\n    require('./components/modebar')\n]);\n\n// locales en and en-US are required for default behavior\nregister([\n    require('./locale-en'),\n    require('./locale-en-us')\n]);\n\n// locales that are present in the window should be loaded\nif(window.PlotlyLocales && Array.isArray(window.PlotlyLocales)) {\n    register(window.PlotlyLocales);\n    delete window.PlotlyLocales;\n}\n\n// plot icons\nexports.Icons = require('./fonts/ploticon');\n\n// unofficial 'beta' plot methods, use at your own risk\nvar Fx = require('./components/fx');\nvar Plots = require('./plots/plots');\n\nexports.Plots = {\n    resize: Plots.resize,\n    graphJson: Plots.graphJson,\n    sendDataToCloud: Plots.sendDataToCloud\n};\nexports.Fx = {\n    hover: Fx.hover,\n    unhover: Fx.unhover,\n    loneHover: Fx.loneHover,\n    loneUnhover: Fx.loneUnhover\n};\nexports.Snapshot = require('./snapshot');\nexports.PlotSchema = require('./plot_api/plot_schema');\n","'use strict';\n\nmodule.exports = {\n    undo: {\n        width: 857.1,\n        height: 1000,\n        path: 'm857 350q0-87-34-166t-91-137-137-92-166-34q-96 0-183 41t-147 114q-4 6-4 13t5 11l76 77q6 5 14 5 9-1 13-7 41-53 100-82t126-29q58 0 110 23t92 61 61 91 22 111-22 111-61 91-92 61-110 23q-55 0-105-20t-90-57l77-77q17-16 8-38-10-23-33-23h-250q-15 0-25 11t-11 25v250q0 24 22 33 22 10 39-8l72-72q60 57 137 88t159 31q87 0 166-34t137-92 91-137 34-166z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    home: {\n        width: 928.6,\n        height: 1000,\n        path: 'm786 296v-267q0-15-11-26t-25-10h-214v214h-143v-214h-214q-15 0-25 10t-11 26v267q0 1 0 2t0 2l321 264 321-264q1-1 1-4z m124 39l-34-41q-5-5-12-6h-2q-7 0-12 3l-386 322-386-322q-7-4-13-4-7 2-12 7l-35 41q-4 5-3 13t6 12l401 334q18 15 42 15t43-15l136-114v109q0 8 5 13t13 5h107q8 0 13-5t5-13v-227l122-102q5-5 6-12t-4-13z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    'camera-retro': {\n        width: 1000,\n        height: 1000,\n        path: 'm518 386q0 8-5 13t-13 5q-37 0-63-27t-26-63q0-8 5-13t13-5 12 5 5 13q0 23 16 38t38 16q8 0 13 5t5 13z m125-73q0-59-42-101t-101-42-101 42-42 101 42 101 101 42 101-42 42-101z m-572-320h858v71h-858v-71z m643 320q0 89-62 152t-152 62-151-62-63-152 63-151 151-63 152 63 62 151z m-571 358h214v72h-214v-72z m-72-107h858v143h-462l-36-71h-360v-72z m929 143v-714q0-30-21-51t-50-21h-858q-29 0-50 21t-21 51v714q0 30 21 51t50 21h858q29 0 50-21t21-51z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    zoombox: {\n        width: 1000,\n        height: 1000,\n        path: 'm1000-25l-250 251c40 63 63 138 63 218 0 224-182 406-407 406-224 0-406-182-406-406s183-406 407-406c80 0 155 22 218 62l250-250 125 125z m-812 250l0 438 437 0 0-438-437 0z m62 375l313 0 0-312-313 0 0 312z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    pan: {\n        width: 1000,\n        height: 1000,\n        path: 'm1000 350l-187 188 0-125-250 0 0 250 125 0-188 187-187-187 125 0 0-250-250 0 0 125-188-188 186-187 0 125 252 0 0-250-125 0 187-188 188 188-125 0 0 250 250 0 0-126 187 188z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    zoom_plus: {\n        width: 875,\n        height: 1000,\n        path: 'm1 787l0-875 875 0 0 875-875 0z m687-500l-187 0 0-187-125 0 0 187-188 0 0 125 188 0 0 187 125 0 0-187 187 0 0-125z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    zoom_minus: {\n        width: 875,\n        height: 1000,\n        path: 'm0 788l0-876 875 0 0 876-875 0z m688-500l-500 0 0 125 500 0 0-125z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    autoscale: {\n        width: 1000,\n        height: 1000,\n        path: 'm250 850l-187 0-63 0 0-62 0-188 63 0 0 188 187 0 0 62z m688 0l-188 0 0-62 188 0 0-188 62 0 0 188 0 62-62 0z m-875-938l0 188-63 0 0-188 0-62 63 0 187 0 0 62-187 0z m875 188l0-188-188 0 0-62 188 0 62 0 0 62 0 188-62 0z m-125 188l-1 0-93-94-156 156 156 156 92-93 2 0 0 250-250 0 0-2 93-92-156-156-156 156 94 92 0 2-250 0 0-250 0 0 93 93 157-156-157-156-93 94 0 0 0-250 250 0 0 0-94 93 156 157 156-157-93-93 0 0 250 0 0 250z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    tooltip_basic: {\n        width: 1500,\n        height: 1000,\n        path: 'm375 725l0 0-375-375 375-374 0-1 1125 0 0 750-1125 0z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    tooltip_compare: {\n        width: 1125,\n        height: 1000,\n        path: 'm187 786l0 2-187-188 188-187 0 0 937 0 0 373-938 0z m0-499l0 1-187-188 188-188 0 0 937 0 0 376-938-1z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    plotlylogo: {\n        width: 1542,\n        height: 1000,\n        path: 'm0-10h182v-140h-182v140z m228 146h183v-286h-183v286z m225 714h182v-1000h-182v1000z m225-285h182v-715h-182v715z m225 142h183v-857h-183v857z m231-428h182v-429h-182v429z m225-291h183v-138h-183v138z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    'z-axis': {\n        width: 1000,\n        height: 1000,\n        path: 'm833 5l-17 108v41l-130-65 130-66c0 0 0 38 0 39 0-1 36-14 39-25 4-15-6-22-16-30-15-12-39-16-56-20-90-22-187-23-279-23-261 0-341 34-353 59 3 60 228 110 228 110-140-8-351-35-351-116 0-120 293-142 474-142 155 0 477 22 477 142 0 50-74 79-163 96z m-374 94c-58-5-99-21-99-40 0-24 65-43 144-43 79 0 143 19 143 43 0 19-42 34-98 40v216h87l-132 135-133-135h88v-216z m167 515h-136v1c16 16 31 34 46 52l84 109v54h-230v-71h124v-1c-16-17-28-32-44-51l-89-114v-51h245v72z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    '3d_rotate': {\n        width: 1000,\n        height: 1000,\n        path: 'm922 660c-5 4-9 7-14 11-359 263-580-31-580-31l-102 28 58-400c0 1 1 1 2 2 118 108 351 249 351 249s-62 27-100 42c88 83 222 183 347 122 16-8 30-17 44-27-2 1-4 2-6 4z m36-329c0 0 64 229-88 296-62 27-124 14-175-11 157-78 225-208 249-266 8-19 11-31 11-31 2 5 6 15 11 32-5-13-8-20-8-20z m-775-239c70-31 117-50 198-32-121 80-199 346-199 346l-96-15-58-12c0 0 55-226 155-287z m603 133l-317-139c0 0 4-4 19-14 7-5 24-15 24-15s-177-147-389 4c235-287 536-112 536-112l31-22 100 299-4-1z m-298-153c6-4 14-9 24-15 0 0-17 10-24 15z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    camera: {\n        width: 1000,\n        height: 1000,\n        path: 'm500 450c-83 0-150-67-150-150 0-83 67-150 150-150 83 0 150 67 150 150 0 83-67 150-150 150z m400 150h-120c-16 0-34 13-39 29l-31 93c-6 15-23 28-40 28h-340c-16 0-34-13-39-28l-31-94c-6-15-23-28-40-28h-120c-55 0-100-45-100-100v-450c0-55 45-100 100-100h800c55 0 100 45 100 100v450c0 55-45 100-100 100z m-400-550c-138 0-250 112-250 250 0 138 112 250 250 250 138 0 250-112 250-250 0-138-112-250-250-250z m365 380c-19 0-35 16-35 35 0 19 16 35 35 35 19 0 35-16 35-35 0-19-16-35-35-35z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    movie: {\n        width: 1000,\n        height: 1000,\n        path: 'm938 413l-188-125c0 37-17 71-44 94 64 38 107 107 107 187 0 121-98 219-219 219-121 0-219-98-219-219 0-61 25-117 66-156h-115c30 33 49 76 49 125 0 103-84 187-187 187s-188-84-188-187c0-57 26-107 65-141-38-22-65-62-65-109v-250c0-70 56-126 125-126h500c69 0 125 56 125 126l188-126c34 0 62 28 62 63v375c0 35-28 63-62 63z m-750 0c-69 0-125 56-125 125s56 125 125 125 125-56 125-125-56-125-125-125z m406-1c-87 0-157 70-157 157 0 86 70 156 157 156s156-70 156-156-70-157-156-157z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    question: {\n        width: 857.1,\n        height: 1000,\n        path: 'm500 82v107q0 8-5 13t-13 5h-107q-8 0-13-5t-5-13v-107q0-8 5-13t13-5h107q8 0 13 5t5 13z m143 375q0 49-31 91t-77 65-95 23q-136 0-207-119-9-14 4-24l74-55q4-4 10-4 9 0 14 7 30 38 48 51 19 14 48 14 27 0 48-15t21-33q0-21-11-34t-38-25q-35-16-65-48t-29-70v-20q0-8 5-13t13-5h107q8 0 13 5t5 13q0 10 12 27t30 28q18 10 28 16t25 19 25 27 16 34 7 45z m214-107q0-117-57-215t-156-156-215-58-216 58-155 156-58 215 58 215 155 156 216 58 215-58 156-156 57-215z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    disk: {\n        width: 857.1,\n        height: 1000,\n        path: 'm214-7h429v214h-429v-214z m500 0h72v500q0 8-6 21t-11 20l-157 156q-5 6-19 12t-22 5v-232q0-22-15-38t-38-16h-322q-22 0-37 16t-16 38v232h-72v-714h72v232q0 22 16 38t37 16h465q22 0 38-16t15-38v-232z m-214 518v178q0 8-5 13t-13 5h-107q-7 0-13-5t-5-13v-178q0-8 5-13t13-5h107q7 0 13 5t5 13z m357-18v-518q0-22-15-38t-38-16h-750q-23 0-38 16t-16 38v750q0 22 16 38t38 16h517q23 0 50-12t42-26l156-157q16-15 27-42t11-49z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    drawopenpath: {\n        width: 70,\n        height: 70,\n        path: 'M33.21,85.65a7.31,7.31,0,0,1-2.59-.48c-8.16-3.11-9.27-19.8-9.88-41.3-.1-3.58-.19-6.68-.35-9-.15-2.1-.67-3.48-1.43-3.79-2.13-.88-7.91,2.32-12,5.86L3,32.38c1.87-1.64,11.55-9.66,18.27-6.9,2.13.87,4.75,3.14,5.17,9,.17,2.43.26,5.59.36,9.25a224.17,224.17,0,0,0,1.5,23.4c1.54,10.76,4,12.22,4.48,12.4.84.32,2.79-.46,5.76-3.59L43,80.07C41.53,81.57,37.68,85.64,33.21,85.65ZM74.81,69a11.34,11.34,0,0,0,6.09-6.72L87.26,44.5,74.72,32,56.9,38.35c-2.37.86-5.57,3.42-6.61,6L38.65,72.14l8.42,8.43ZM55,46.27a7.91,7.91,0,0,1,3.64-3.17l14.8-5.3,8,8L76.11,60.6l-.06.19a6.37,6.37,0,0,1-3,3.43L48.25,74.59,44.62,71Zm16.57,7.82A6.9,6.9,0,1,0,64.64,61,6.91,6.91,0,0,0,71.54,54.09Zm-4.05,0a2.85,2.85,0,1,1-2.85-2.85A2.86,2.86,0,0,1,67.49,54.09Zm-4.13,5.22L60.5,56.45,44.26,72.7l2.86,2.86ZM97.83,35.67,84.14,22l-8.57,8.57L89.26,44.24Zm-13.69-8,8,8-2.85,2.85-8-8Z',\n        transform: 'matrix(1 0 0 1 -15 -15)'\n    },\n    drawclosedpath: {\n        width: 90,\n        height: 90,\n        path: 'M88.41,21.12a26.56,26.56,0,0,0-36.18,0l-2.07,2-2.07-2a26.57,26.57,0,0,0-36.18,0,23.74,23.74,0,0,0,0,34.8L48,90.12a3.22,3.22,0,0,0,4.42,0l36-34.21a23.73,23.73,0,0,0,0-34.79ZM84,51.24,50.16,83.35,16.35,51.25a17.28,17.28,0,0,1,0-25.47,20,20,0,0,1,27.3,0l4.29,4.07a3.23,3.23,0,0,0,4.44,0l4.29-4.07a20,20,0,0,1,27.3,0,17.27,17.27,0,0,1,0,25.46ZM66.76,47.68h-33v6.91h33ZM53.35,35H46.44V68h6.91Z',\n        transform: 'matrix(1 0 0 1 -5 -5)'\n    },\n    lasso: {\n        width: 1031,\n        height: 1000,\n        path: 'm1018 538c-36 207-290 336-568 286-277-48-473-256-436-463 10-57 36-108 76-151-13-66 11-137 68-183 34-28 75-41 114-42l-55-70 0 0c-2-1-3-2-4-3-10-14-8-34 5-45 14-11 34-8 45 4 1 1 2 3 2 5l0 0 113 140c16 11 31 24 45 40 4 3 6 7 8 11 48-3 100 0 151 9 278 48 473 255 436 462z m-624-379c-80 14-149 48-197 96 42 42 109 47 156 9 33-26 47-66 41-105z m-187-74c-19 16-33 37-39 60 50-32 109-55 174-68-42-25-95-24-135 8z m360 75c-34-7-69-9-102-8 8 62-16 128-68 170-73 59-175 54-244-5-9 20-16 40-20 61-28 159 121 317 333 354s407-60 434-217c28-159-121-318-333-355z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    selectbox: {\n        width: 1000,\n        height: 1000,\n        path: 'm0 850l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-285l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z',\n        transform: 'matrix(1 0 0 -1 0 850)'\n    },\n    drawline: {\n        width: 70,\n        height: 70,\n        path: 'M60.64,62.3a11.29,11.29,0,0,0,6.09-6.72l6.35-17.72L60.54,25.31l-17.82,6.4c-2.36.86-5.57,3.41-6.6,6L24.48,65.5l8.42,8.42ZM40.79,39.63a7.89,7.89,0,0,1,3.65-3.17l14.79-5.31,8,8L61.94,54l-.06.19a6.44,6.44,0,0,1-3,3.43L34.07,68l-3.62-3.63Zm16.57,7.81a6.9,6.9,0,1,0-6.89,6.9A6.9,6.9,0,0,0,57.36,47.44Zm-4,0a2.86,2.86,0,1,1-2.85-2.85A2.86,2.86,0,0,1,53.32,47.44Zm-4.13,5.22L46.33,49.8,30.08,66.05l2.86,2.86ZM83.65,29,70,15.34,61.4,23.9,75.09,37.59ZM70,21.06l8,8-2.84,2.85-8-8ZM87,80.49H10.67V87H87Z',\n        transform: 'matrix(1 0 0 1 -15 -15)'\n    },\n    drawrect: {\n        width: 80,\n        height: 80,\n        path: 'M78,22V79H21V22H78m9-9H12V88H87V13ZM68,46.22H31V54H68ZM53,32H45.22V69H53Z',\n        transform: 'matrix(1 0 0 1 -10 -10)'\n    },\n    drawcircle: {\n        width: 80,\n        height: 80,\n        path: 'M50,84.72C26.84,84.72,8,69.28,8,50.3S26.84,15.87,50,15.87,92,31.31,92,50.3,73.16,84.72,50,84.72Zm0-60.59c-18.6,0-33.74,11.74-33.74,26.17S31.4,76.46,50,76.46,83.74,64.72,83.74,50.3,68.6,24.13,50,24.13Zm17.15,22h-34v7.11h34Zm-13.8-13H46.24v34h7.11Z',\n        transform: 'matrix(1 0 0 1 -10 -10)'\n    },\n    eraseshape: {\n        width: 80,\n        height: 80,\n        path: 'M82.77,78H31.85L6,49.57,31.85,21.14H82.77a8.72,8.72,0,0,1,8.65,8.77V69.24A8.72,8.72,0,0,1,82.77,78ZM35.46,69.84H82.77a.57.57,0,0,0,.49-.6V29.91a.57.57,0,0,0-.49-.61H35.46L17,49.57Zm32.68-34.7-24,24,5,5,24-24Zm-19,.53-5,5,24,24,5-5Z',\n        transform: 'matrix(1 0 0 1 -10 -10)'\n    },\n    spikeline: {\n        width: 1000,\n        height: 1000,\n        path: 'M512 409c0-57-46-104-103-104-57 0-104 47-104 104 0 57 47 103 104 103 57 0 103-46 103-103z m-327-39l92 0 0 92-92 0z m-185 0l92 0 0 92-92 0z m370-186l92 0 0 93-92 0z m0-184l92 0 0 92-92 0z',\n        transform: 'matrix(1.5 0 0 -1.5 0 850)'\n    },\n    pencil: {\n        width: 1792,\n        height: 1792,\n        path: 'M491 1536l91-91-235-235-91 91v107h128v128h107zm523-928q0-22-22-22-10 0-17 7l-542 542q-7 7-7 17 0 22 22 22 10 0 17-7l542-542q7-7 7-17zm-54-192l416 416-832 832h-416v-416zm683 96q0 53-37 90l-166 166-416-416 166-165q36-38 90-38 53 0 91 38l235 234q37 39 37 91z',\n        transform: 'matrix(1 0 0 1 0 1)'\n    },\n    newplotlylogo: {\n        name: 'newplotlylogo',\n        svg: [\n            '<svg xmlns=\\'http://www.w3.org/2000/svg\\' viewBox=\\'0 0 132 132\\'>',\n            '<defs>',\n            ' <style>',\n            '  .cls-0{fill:#000;}',\n            '  .cls-1{fill:#FFF;}',\n            '  .cls-2{fill:#F26;}',\n            '  .cls-3{fill:#D69;}',\n            '  .cls-4{fill:#BAC;}',\n            '  .cls-5{fill:#9EF;}',\n            ' </style>',\n            '</defs>',\n            ' <title>plotly-logomark</title>',\n            ' <g id=\\'symbol\\'>',\n            '  <rect class=\\'cls-0\\' x=\\'0\\' y=\\'0\\' width=\\'132\\' height=\\'132\\' rx=\\'18\\' ry=\\'18\\'/>',\n            '  <circle class=\\'cls-5\\' cx=\\'102\\' cy=\\'30\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-4\\' cx=\\'78\\' cy=\\'30\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-4\\' cx=\\'78\\' cy=\\'54\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-3\\' cx=\\'54\\' cy=\\'30\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-2\\' cx=\\'30\\' cy=\\'30\\' r=\\'6\\'/>',\n            '  <circle class=\\'cls-2\\' cx=\\'30\\' cy=\\'54\\' r=\\'6\\'/>',\n            '  <path class=\\'cls-1\\' d=\\'M30,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,30,72Z\\'/>',\n            '  <path class=\\'cls-1\\' d=\\'M78,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,78,72Z\\'/>',\n            '  <path class=\\'cls-1\\' d=\\'M54,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,54,48Z\\'/>',\n            '  <path class=\\'cls-1\\' d=\\'M102,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,102,48Z\\'/>',\n            ' </g>',\n            '</svg>'\n        ].join('')\n    }\n};\n","'use strict';\n\n\n/**\n * Determine the position anchor property of x/y xanchor/yanchor components.\n *\n * - values < 1/3 align the low side at that fraction,\n * - values [1/3, 2/3] align the center at that fraction,\n * - values > 2/3 align the right at that fraction.\n */\n\n\nexports.isLeftAnchor = function isLeftAnchor(opts) {\n    return (\n      opts.xanchor === 'left' ||\n      (opts.xanchor === 'auto' && opts.x <= 1 / 3)\n    );\n};\n\nexports.isCenterAnchor = function isCenterAnchor(opts) {\n    return (\n        opts.xanchor === 'center' ||\n        (opts.xanchor === 'auto' && opts.x > 1 / 3 && opts.x < 2 / 3)\n    );\n};\n\nexports.isRightAnchor = function isRightAnchor(opts) {\n    return (\n      opts.xanchor === 'right' ||\n      (opts.xanchor === 'auto' && opts.x >= 2 / 3)\n    );\n};\n\nexports.isTopAnchor = function isTopAnchor(opts) {\n    return (\n        opts.yanchor === 'top' ||\n        (opts.yanchor === 'auto' && opts.y >= 2 / 3)\n    );\n};\n\nexports.isMiddleAnchor = function isMiddleAnchor(opts) {\n    return (\n        opts.yanchor === 'middle' ||\n        (opts.yanchor === 'auto' && opts.y > 1 / 3 && opts.y < 2 / 3)\n    );\n};\n\nexports.isBottomAnchor = function isBottomAnchor(opts) {\n    return (\n      opts.yanchor === 'bottom' ||\n      (opts.yanchor === 'auto' && opts.y <= 1 / 3)\n    );\n};\n","'use strict';\n\nvar modModule = require('./mod');\nvar mod = modModule.mod;\nvar modHalf = modModule.modHalf;\n\nvar PI = Math.PI;\nvar twoPI = 2 * PI;\n\nfunction deg2rad(deg) { return deg / 180 * PI; }\n\nfunction rad2deg(rad) { return rad / PI * 180; }\n\n/**\n * is sector a full circle?\n * ... this comes up a lot in SVG path-drawing routines\n *\n * N.B. we consider all sectors that span more that 2pi 'full' circles\n *\n * @param {2-item array} aBnds : angular bounds in *radians*\n * @return {boolean}\n */\nfunction isFullCircle(aBnds) {\n    return Math.abs(aBnds[1] - aBnds[0]) > twoPI - 1e-14;\n}\n\n/**\n * angular delta between angle 'a' and 'b'\n * solution taken from: https://stackoverflow.com/a/2007279\n *\n * @param {number} a : first angle in *radians*\n * @param {number} b : second angle in *radians*\n * @return {number} angular delta in *radians*\n */\nfunction angleDelta(a, b) {\n    return modHalf(b - a, twoPI);\n}\n\n/**\n * angular distance between angle 'a' and 'b'\n *\n * @param {number} a : first angle in *radians*\n * @param {number} b : second angle in *radians*\n * @return {number} angular distance in *radians*\n */\nfunction angleDist(a, b) {\n    return Math.abs(angleDelta(a, b));\n}\n\n/**\n * is angle inside sector?\n *\n * @param {number} a : angle to test in *radians*\n * @param {2-item array} aBnds : sector's angular bounds in *radians*\n * @param {boolean}\n */\nfunction isAngleInsideSector(a, aBnds) {\n    if(isFullCircle(aBnds)) return true;\n\n    var s0, s1;\n\n    if(aBnds[0] < aBnds[1]) {\n        s0 = aBnds[0];\n        s1 = aBnds[1];\n    } else {\n        s0 = aBnds[1];\n        s1 = aBnds[0];\n    }\n\n    s0 = mod(s0, twoPI);\n    s1 = mod(s1, twoPI);\n    if(s0 > s1) s1 += twoPI;\n\n    var a0 = mod(a, twoPI);\n    var a1 = a0 + twoPI;\n\n    return (a0 >= s0 && a0 <= s1) || (a1 >= s0 && a1 <= s1);\n}\n\n/**\n * is pt (r,a) inside sector?\n *\n * @param {number} r : pt's radial coordinate\n * @param {number} a : pt's angular coordinate in *radians*\n * @param {2-item array} rBnds : sector's radial bounds\n * @param {2-item array} aBnds : sector's angular bounds in *radians*\n * @return {boolean}\n */\nfunction isPtInsideSector(r, a, rBnds, aBnds) {\n    if(!isAngleInsideSector(a, aBnds)) return false;\n\n    var r0, r1;\n\n    if(rBnds[0] < rBnds[1]) {\n        r0 = rBnds[0];\n        r1 = rBnds[1];\n    } else {\n        r0 = rBnds[1];\n        r1 = rBnds[0];\n    }\n\n    return r >= r0 && r <= r1;\n}\n\n// common to pathArc, pathSector and pathAnnulus\nfunction _path(r0, r1, a0, a1, cx, cy, isClosed) {\n    cx = cx || 0;\n    cy = cy || 0;\n\n    var isCircle = isFullCircle([a0, a1]);\n    var aStart, aMid, aEnd;\n    var rStart, rEnd;\n\n    if(isCircle) {\n        aStart = 0;\n        aMid = PI;\n        aEnd = twoPI;\n    } else {\n        if(a0 < a1) {\n            aStart = a0;\n            aEnd = a1;\n        } else {\n            aStart = a1;\n            aEnd = a0;\n        }\n    }\n\n    if(r0 < r1) {\n        rStart = r0;\n        rEnd = r1;\n    } else {\n        rStart = r1;\n        rEnd = r0;\n    }\n\n    // N.B. svg coordinates here, where y increases downward\n    function pt(r, a) {\n        return [r * Math.cos(a) + cx, cy - r * Math.sin(a)];\n    }\n\n    var largeArc = Math.abs(aEnd - aStart) <= PI ? 0 : 1;\n    function arc(r, a, cw) {\n        return 'A' + [r, r] + ' ' + [0, largeArc, cw] + ' ' + pt(r, a);\n    }\n\n    var p;\n\n    if(isCircle) {\n        if(rStart === null) {\n            p = 'M' + pt(rEnd, aStart) +\n                arc(rEnd, aMid, 0) +\n                arc(rEnd, aEnd, 0) + 'Z';\n        } else {\n            p = 'M' + pt(rStart, aStart) +\n                arc(rStart, aMid, 0) +\n                arc(rStart, aEnd, 0) + 'Z' +\n                'M' + pt(rEnd, aStart) +\n                arc(rEnd, aMid, 1) +\n                arc(rEnd, aEnd, 1) + 'Z';\n        }\n    } else {\n        if(rStart === null) {\n            p = 'M' + pt(rEnd, aStart) + arc(rEnd, aEnd, 0);\n            if(isClosed) p += 'L0,0Z';\n        } else {\n            p = 'M' + pt(rStart, aStart) +\n                'L' + pt(rEnd, aStart) +\n                arc(rEnd, aEnd, 0) +\n                'L' + pt(rStart, aEnd) +\n                arc(rStart, aStart, 1) + 'Z';\n        }\n    }\n\n    return p;\n}\n\n/**\n * path an arc\n *\n * @param {number} r : radius\n * @param {number} a0 : first angular coordinate in *radians*\n * @param {number} a1 : second angular coordinate in *radians*\n * @param {number (optional)} cx : x coordinate of center\n * @param {number (optional)} cy : y coordinate of center\n * @return {string} svg path\n */\nfunction pathArc(r, a0, a1, cx, cy) {\n    return _path(null, r, a0, a1, cx, cy, 0);\n}\n\n/**\n * path a sector\n *\n * @param {number} r : radius\n * @param {number} a0 : first angular coordinate in *radians*\n * @param {number} a1 : second angular coordinate in *radians*\n * @param {number (optional)} cx : x coordinate of center\n * @param {number (optional)} cy : y coordinate of center\n * @return {string} svg path\n */\nfunction pathSector(r, a0, a1, cx, cy) {\n    return _path(null, r, a0, a1, cx, cy, 1);\n}\n\n/**\n * path an annulus\n *\n * @param {number} r0 : first radial coordinate\n * @param {number} r1 : second radial coordinate\n * @param {number} a0 : first angular coordinate in *radians*\n * @param {number} a1 : second angular coordinate in *radians*\n * @param {number (optional)} cx : x coordinate of center\n * @param {number (optional)} cy : y coordinate of center\n * @return {string} svg path\n */\nfunction pathAnnulus(r0, r1, a0, a1, cx, cy) {\n    return _path(r0, r1, a0, a1, cx, cy, 1);\n}\n\nmodule.exports = {\n    deg2rad: deg2rad,\n    rad2deg: rad2deg,\n    angleDelta: angleDelta,\n    angleDist: angleDist,\n    isFullCircle: isFullCircle,\n    isAngleInsideSector: isAngleInsideSector,\n    isPtInsideSector: isPtInsideSector,\n    pathArc: pathArc,\n    pathSector: pathSector,\n    pathAnnulus: pathAnnulus\n};\n","'use strict';\nvar b64decode = require('base64-arraybuffer').decode;\n\nvar isPlainObject = require('./is_plain_object');\n\nvar isArray = Array.isArray;\n\nvar ab = ArrayBuffer;\nvar dv = DataView;\n\nfunction isTypedArray(a) {\n    return ab.isView(a) && !(a instanceof dv);\n}\nexports.isTypedArray = isTypedArray;\n\nfunction isArrayOrTypedArray(a) {\n    return isArray(a) || isTypedArray(a);\n}\nexports.isArrayOrTypedArray = isArrayOrTypedArray;\n\n/*\n * Test whether an input object is 1D.\n *\n * Assumes we already know the object is an array.\n *\n * Looks only at the first element, if the dimensionality is\n * not consistent we won't figure that out here.\n */\nfunction isArray1D(a) {\n    return !isArrayOrTypedArray(a[0]);\n}\nexports.isArray1D = isArray1D;\n\n/*\n * Ensures an array has the right amount of storage space. If it doesn't\n * exist, it creates an array. If it does exist, it returns it if too\n * short or truncates it in-place.\n *\n * The goal is to just reuse memory to avoid a bit of excessive garbage\n * collection.\n */\nexports.ensureArray = function(out, n) {\n    // TODO: typed array support here? This is only used in\n    // traces/carpet/compute_control_points\n    if(!isArray(out)) out = [];\n\n    // If too long, truncate. (If too short, it will grow\n    // automatically so we don't care about that case)\n    out.length = n;\n\n    return out;\n};\n\nvar typedArrays = {\n    u1c: typeof Uint8ClampedArray === 'undefined' ? undefined :\n                Uint8ClampedArray, // not supported in numpy?\n\n    i1: typeof Int8Array === 'undefined' ? undefined :\n               Int8Array,\n\n    u1: typeof Uint8Array === 'undefined' ? undefined :\n               Uint8Array,\n\n    i2: typeof Int16Array === 'undefined' ? undefined :\n               Int16Array,\n\n    u2: typeof Uint16Array === 'undefined' ? undefined :\n               Uint16Array,\n\n    i4: typeof Int32Array === 'undefined' ? undefined :\n               Int32Array,\n\n    u4: typeof Uint32Array === 'undefined' ? undefined :\n               Uint32Array,\n\n    f4: typeof Float32Array === 'undefined' ? undefined :\n               Float32Array,\n\n    f8: typeof Float64Array === 'undefined' ? undefined :\n               Float64Array,\n\n    /* TODO: potentially add Big Int\n\n    i8: typeof BigInt64Array === 'undefined' ? undefined :\n               BigInt64Array,\n\n    u8: typeof BigUint64Array === 'undefined' ? undefined :\n               BigUint64Array,\n    */\n};\n\ntypedArrays.uint8c = typedArrays.u1c;\ntypedArrays.uint8 = typedArrays.u1;\ntypedArrays.int8 = typedArrays.i1;\ntypedArrays.uint16 = typedArrays.u2;\ntypedArrays.int16 = typedArrays.i2;\ntypedArrays.uint32 = typedArrays.u4;\ntypedArrays.int32 = typedArrays.i4;\ntypedArrays.float32 = typedArrays.f4;\ntypedArrays.float64 = typedArrays.f8;\n\nfunction isArrayBuffer(a) {\n    return a.constructor === ArrayBuffer;\n}\nexports.isArrayBuffer = isArrayBuffer;\n\nexports.decodeTypedArraySpec = function(vIn) {\n    var out = [];\n    var v = coerceTypedArraySpec(vIn);\n    var dtype = v.dtype;\n\n    var T = typedArrays[dtype];\n    if(!T) throw new Error('Error in dtype: \"' + dtype + '\"');\n    var BYTES_PER_ELEMENT = T.BYTES_PER_ELEMENT;\n\n    var buffer = v.bdata;\n    if(!isArrayBuffer(buffer)) {\n        buffer = b64decode(buffer);\n    }\n    var shape = v.shape === undefined ?\n        // detect 1-d length\n        [buffer.byteLength / BYTES_PER_ELEMENT] :\n        // convert number to string and split to array\n        ('' + v.shape).split(',');\n\n    shape.reverse(); // i.e. to match numpy order\n    var ndim = shape.length;\n\n    var nj, j;\n    var ni = +shape[0];\n\n    var rowBytes = BYTES_PER_ELEMENT * ni;\n    var pos = 0;\n\n    if(ndim === 1) {\n        out = new T(buffer);\n    } else if(ndim === 2) {\n        nj = +shape[1];\n        for(j = 0; j < nj; j++) {\n            out[j] = new T(buffer, pos, ni);\n            pos += rowBytes;\n        }\n    } else if(ndim === 3) {\n        nj = +shape[1];\n        var nk = +shape[2];\n        for(var k = 0; k < nk; k++) {\n            out[k] = [];\n            for(j = 0; j < nj; j++) {\n                out[k][j] = new T(buffer, pos, ni);\n                pos += rowBytes;\n            }\n        }\n    } else {\n        throw new Error('ndim: ' + ndim + 'is not supported with the shape:\"' + v.shape + '\"');\n    }\n\n    // attach bdata, dtype & shape to array for json export\n    out.bdata = v.bdata;\n    out.dtype = v.dtype;\n    out.shape = shape.reverse().join(',');\n\n    vIn._inputArray = out;\n\n    return out;\n};\n\nexports.isTypedArraySpec = function(v) {\n    return (\n        isPlainObject(v) &&\n        v.hasOwnProperty('dtype') && (typeof v.dtype === 'string') &&\n\n        v.hasOwnProperty('bdata') && (typeof v.bdata === 'string' || isArrayBuffer(v.bdata)) &&\n\n        (v.shape === undefined || (\n            v.hasOwnProperty('shape') && (typeof v.shape === 'string' || typeof v.shape === 'number')\n        ))\n    );\n};\n\nfunction coerceTypedArraySpec(v) {\n    return {\n        bdata: v.bdata,\n        dtype: v.dtype,\n        shape: v.shape\n    };\n}\n\n/*\n * TypedArray-compatible concatenation of n arrays\n * if all arrays are the same type it will preserve that type,\n * otherwise it falls back on Array.\n * Also tries to avoid copying, in case one array has zero length\n * But never mutates an existing array\n */\nexports.concat = function() {\n    var args = [];\n    var allArray = true;\n    var totalLen = 0;\n\n    var _constructor, arg0, i, argi, posi, leni, out, j;\n\n    for(i = 0; i < arguments.length; i++) {\n        argi = arguments[i];\n        leni = argi.length;\n        if(leni) {\n            if(arg0) args.push(argi);\n            else {\n                arg0 = argi;\n                posi = leni;\n            }\n\n            if(isArray(argi)) {\n                _constructor = false;\n            } else {\n                allArray = false;\n                if(!totalLen) {\n                    _constructor = argi.constructor;\n                } else if(_constructor !== argi.constructor) {\n                    // TODO: in principle we could upgrade here,\n                    // ie keep typed array but convert all to Float64Array?\n                    _constructor = false;\n                }\n            }\n\n            totalLen += leni;\n        }\n    }\n\n    if(!totalLen) return [];\n    if(!args.length) return arg0;\n\n    if(allArray) return arg0.concat.apply(arg0, args);\n    if(_constructor) {\n        // matching typed arrays\n        out = new _constructor(totalLen);\n        out.set(arg0);\n        for(i = 0; i < args.length; i++) {\n            argi = args[i];\n            out.set(argi, posi);\n            posi += argi.length;\n        }\n        return out;\n    }\n\n    // mismatched types or Array + typed\n    out = new Array(totalLen);\n    for(j = 0; j < arg0.length; j++) out[j] = arg0[j];\n    for(i = 0; i < args.length; i++) {\n        argi = args[i];\n        for(j = 0; j < argi.length; j++) out[posi + j] = argi[j];\n        posi += j;\n    }\n    return out;\n};\n\nexports.maxRowLength = function(z) {\n    return _rowLength(z, Math.max, 0);\n};\n\nexports.minRowLength = function(z) {\n    return _rowLength(z, Math.min, Infinity);\n};\n\nfunction _rowLength(z, fn, len0) {\n    if(isArrayOrTypedArray(z)) {\n        if(isArrayOrTypedArray(z[0])) {\n            var len = len0;\n            for(var i = 0; i < z.length; i++) {\n                len = fn(len, z[i].length);\n            }\n            return len;\n        } else {\n            return z.length;\n        }\n    }\n    return 0;\n}\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\n\nvar BADNUM = require('../constants/numerical').BADNUM;\n\n// precompile for speed\nvar JUNK = /^['\"%,$#\\s']+|[, ]|['\"%,$#\\s']+$/g;\n\n/**\n * cleanNumber: remove common leading and trailing cruft\n * Always returns either a number or BADNUM.\n */\nmodule.exports = function cleanNumber(v) {\n    if(typeof v === 'string') {\n        v = v.replace(JUNK, '');\n    }\n\n    if(isNumeric(v)) return Number(v);\n\n    return BADNUM;\n};\n","'use strict';\n\n/**\n * Clear gl frame (if any). This is a common pattern as\n * we usually set `preserveDrawingBuffer: true` during\n * gl context creation (e.g. via `reglUtils.prepare`).\n *\n * @param {DOM node or object} gd : graph div object\n */\nmodule.exports = function clearGlCanvases(gd) {\n    var fullLayout = gd._fullLayout;\n\n    if(fullLayout._glcanvas && fullLayout._glcanvas.size()) {\n        fullLayout._glcanvas.each(function(d) {\n            if(d.regl) d.regl.clear({color: true, depth: true});\n        });\n    }\n};\n","'use strict';\n\n/**\n * Clear responsive handlers (if any).\n *\n * @param {DOM node or object} gd : graph div object\n */\nmodule.exports = function clearResponsive(gd) {\n    if(gd._responsiveChartHandler) {\n        window.removeEventListener('resize', gd._responsiveChartHandler);\n        delete gd._responsiveChartHandler;\n    }\n};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\nvar tinycolor = require('tinycolor2');\n\nvar baseTraceAttrs = require('../plots/attributes');\nvar colorscales = require('../components/colorscale/scales');\nvar Color = require('../components/color');\nvar DESELECTDIM = require('../constants/interactions').DESELECTDIM;\n\nvar nestedProperty = require('./nested_property');\nvar counterRegex = require('./regex').counter;\nvar modHalf = require('./mod').modHalf;\nvar isArrayOrTypedArray = require('./array').isArrayOrTypedArray;\nvar isTypedArraySpec = require('./array').isTypedArraySpec;\nvar decodeTypedArraySpec = require('./array').decodeTypedArraySpec;\n\nexports.valObjectMeta = {\n    data_array: {\n        // You can use *dflt=[] to force said array to exist though.\n        description: [\n            'An {array} of data.',\n            'The value must represent an {array} or it will be ignored,',\n            'but this array can be provided in several forms:',\n            '(1) a regular {array} object',\n            '(2) a typed array (e.g. Float32Array)',\n            '(3) an object with keys dtype, bdata, and optionally shape.',\n            'In this 3rd form, dtype is one of',\n            '*f8*, *f4*.',\n            '*i4*, *u4*,',\n            '*i2*, *u2*,',\n            '*i1*, *u1* or *u1c* for Uint8ClampedArray.',\n            'In addition to shorthand `dtype` above one could also use the following forms:',\n            '*float64*, *float32*,',\n            '*int32*, *uint32*,',\n            '*int16*, *uint16*,',\n            '*int8*, *uint8* or *uint8c* for Uint8ClampedArray.',\n            '`bdata` is either a base64-encoded string or the ArrayBuffer of',\n            'an integer or float typed array.',\n            'For either multi-dimensional arrays you must also',\n            'provide its dimensions separated by comma via `shape`.',\n            'For example using `dtype`: *f4* and `shape`: *5,100* you can',\n            'declare a 2-D array that has 5 rows and 100 columns',\n            'containing float32 values i.e. 4 bits per value.',\n            '`shape` is optional for one dimensional arrays.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt'],\n        coerceFunction: function(v, propOut, dflt) {\n            propOut.set(\n                isArrayOrTypedArray(v) ? v :\n                isTypedArraySpec(v) ? decodeTypedArraySpec(v) :\n                dflt\n            );\n        }\n    },\n    enumerated: {\n        description: [\n            'Enumerated value type. The available values are listed',\n            'in `values`.'\n        ].join(' '),\n        requiredOpts: ['values'],\n        otherOpts: ['dflt', 'coerceNumber', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if(opts.coerceNumber) v = +v;\n            if(opts.values.indexOf(v) === -1) propOut.set(dflt);\n            else propOut.set(v);\n        },\n        validateFunction: function(v, opts) {\n            if(opts.coerceNumber) v = +v;\n\n            var values = opts.values;\n            for(var i = 0; i < values.length; i++) {\n                var k = String(values[i]);\n\n                if((k.charAt(0) === '/' && k.charAt(k.length - 1) === '/')) {\n                    var regex = new RegExp(k.substr(1, k.length - 2));\n                    if(regex.test(v)) return true;\n                } else if(v === values[i]) return true;\n            }\n            return false;\n        }\n    },\n    boolean: {\n        description: 'A boolean (true/false) value.',\n        requiredOpts: [],\n        otherOpts: ['dflt'],\n        coerceFunction: function(v, propOut, dflt) {\n            if(v === true || v === false) propOut.set(v);\n            else propOut.set(dflt);\n        }\n    },\n    number: {\n        description: [\n            'A number or a numeric value',\n            '(e.g. a number inside a string).',\n            'When applicable, values greater (less) than `max` (`min`)',\n            'are coerced to the `dflt`.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt', 'min', 'max', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if(!isNumeric(v) ||\n                    (opts.min !== undefined && v < opts.min) ||\n                    (opts.max !== undefined && v > opts.max)) {\n                propOut.set(dflt);\n            } else propOut.set(+v);\n        }\n    },\n    integer: {\n        description: [\n            'An integer or an integer inside a string.',\n            'When applicable, values greater (less) than `max` (`min`)',\n            'are coerced to the `dflt`.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt', 'min', 'max', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if(v % 1 || !isNumeric(v) ||\n                    (opts.min !== undefined && v < opts.min) ||\n                    (opts.max !== undefined && v > opts.max)) {\n                propOut.set(dflt);\n            } else propOut.set(+v);\n        }\n    },\n    string: {\n        description: [\n            'A string value.',\n            'Numbers are converted to strings except for attributes with',\n            '`strict` set to true.'\n        ].join(' '),\n        requiredOpts: [],\n        // TODO 'values shouldn't be in there (edge case: 'dash' in Scatter)\n        otherOpts: ['dflt', 'noBlank', 'strict', 'arrayOk', 'values'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if(typeof v !== 'string') {\n                var okToCoerce = (typeof v === 'number');\n\n                if(opts.strict === true || !okToCoerce) propOut.set(dflt);\n                else propOut.set(String(v));\n            } else if(opts.noBlank && !v) propOut.set(dflt);\n            else propOut.set(v);\n        }\n    },\n    color: {\n        description: [\n            'A string describing color.',\n            'Supported formats:',\n            '- hex (e.g. \\'#d3d3d3\\')',\n            '- rgb (e.g. \\'rgb(255, 0, 0)\\')',\n            '- rgba (e.g. \\'rgb(255, 0, 0, 0.5)\\')',\n            '- hsl (e.g. \\'hsl(0, 100%, 50%)\\')',\n            '- hsv (e.g. \\'hsv(0, 100%, 100%)\\')',\n            '- named colors (full list: http://www.w3.org/TR/css3-color/#svg-color)'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt) {\n            if(tinycolor(v).isValid()) propOut.set(v);\n            else propOut.set(dflt);\n        }\n    },\n    colorlist: {\n        description: [\n            'A list of colors.',\n            'Must be an {array} containing valid colors.',\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt'],\n        coerceFunction: function(v, propOut, dflt) {\n            function isColor(color) {\n                return tinycolor(color).isValid();\n            }\n            if(!Array.isArray(v) || !v.length) propOut.set(dflt);\n            else if(v.every(isColor)) propOut.set(v);\n            else propOut.set(dflt);\n        }\n    },\n    colorscale: {\n        description: [\n            'A Plotly colorscale either picked by a name:',\n            '(any of', Object.keys(colorscales.scales).join(', '), ')',\n            'customized as an {array} of 2-element {arrays} where',\n            'the first element is the normalized color level value',\n            '(starting at *0* and ending at *1*),',\n            'and the second item is a valid color string.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt'],\n        coerceFunction: function(v, propOut, dflt) {\n            propOut.set(colorscales.get(v, dflt));\n        }\n    },\n    angle: {\n        description: [\n            'A number (in degree) between -180 and 180.'\n        ].join(' '),\n        requiredOpts: [],\n        otherOpts: ['dflt', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt) {\n            if(v === 'auto') propOut.set('auto');\n            else if(!isNumeric(v)) propOut.set(dflt);\n            else propOut.set(modHalf(+v, 360));\n        }\n    },\n    subplotid: {\n        description: [\n            'An id string of a subplot type (given by dflt), optionally',\n            'followed by an integer >1. e.g. if dflt=\\'geo\\', we can have',\n            '\\'geo\\', \\'geo2\\', \\'geo3\\', ...'\n        ].join(' '),\n        requiredOpts: ['dflt'],\n        otherOpts: ['regex'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            var regex = opts.regex || counterRegex(dflt);\n            if(typeof v === 'string' && regex.test(v)) {\n                propOut.set(v);\n                return;\n            }\n            propOut.set(dflt);\n        },\n        validateFunction: function(v, opts) {\n            var dflt = opts.dflt;\n\n            if(v === dflt) return true;\n            if(typeof v !== 'string') return false;\n            if(counterRegex(dflt).test(v)) return true;\n\n            return false;\n        }\n    },\n    flaglist: {\n        description: [\n            'A string representing a combination of flags',\n            '(order does not matter here).',\n            'Combine any of the available `flags` with *+*.',\n            '(e.g. (\\'lines+markers\\')).',\n            'Values in `extras` cannot be combined.'\n        ].join(' '),\n        requiredOpts: ['flags'],\n        otherOpts: ['dflt', 'extras', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            if((opts.extras || []).indexOf(v) !== -1) {\n                propOut.set(v);\n                return;\n            }\n            if(typeof v !== 'string') {\n                propOut.set(dflt);\n                return;\n            }\n            var vParts = v.split('+');\n            var i = 0;\n            while(i < vParts.length) {\n                var vi = vParts[i];\n                if(opts.flags.indexOf(vi) === -1 || vParts.indexOf(vi) < i) {\n                    vParts.splice(i, 1);\n                } else i++;\n            }\n            if(!vParts.length) propOut.set(dflt);\n            else propOut.set(vParts.join('+'));\n        }\n    },\n    any: {\n        description: 'Any type.',\n        requiredOpts: [],\n        otherOpts: ['dflt', 'values', 'arrayOk'],\n        coerceFunction: function(v, propOut, dflt) {\n            if(v === undefined) {\n                propOut.set(dflt);\n            } else {\n                propOut.set(\n                    isTypedArraySpec(v) ? decodeTypedArraySpec(v) :\n                    v\n                );\n            }\n        }\n    },\n    info_array: {\n        description: [\n            'An {array} of plot information.'\n        ].join(' '),\n        requiredOpts: ['items'],\n        // set `dimensions=2` for a 2D array or '1-2' for either\n        // `items` may be a single object instead of an array, in which case\n        // `freeLength` must be true.\n        // if `dimensions='1-2'` and items is a 1D array, then the value can\n        // either be a matching 1D array or an array of such matching 1D arrays\n        otherOpts: ['dflt', 'freeLength', 'dimensions'],\n        coerceFunction: function(v, propOut, dflt, opts) {\n            // simplified coerce function just for array items\n            function coercePart(v, opts, dflt) {\n                var out;\n                var propPart = {set: function(v) { out = v; }};\n\n                if(dflt === undefined) dflt = opts.dflt;\n\n                exports.valObjectMeta[opts.valType].coerceFunction(v, propPart, dflt, opts);\n\n                return out;\n            }\n\n            if(isTypedArraySpec(v)) v = decodeTypedArraySpec(v);\n\n            if(!isArrayOrTypedArray(v)) {\n                propOut.set(dflt);\n                return;\n            }\n\n            var twoD = opts.dimensions === 2 || (opts.dimensions === '1-2' && Array.isArray(v) && isArrayOrTypedArray(v[0]));\n\n            var items = opts.items;\n            var vOut = [];\n            var arrayItems = Array.isArray(items);\n            var arrayItems2D = arrayItems && twoD && isArrayOrTypedArray(items[0]);\n            var innerItemsOnly = twoD && arrayItems && !arrayItems2D;\n            var len = (arrayItems && !innerItemsOnly) ? items.length : v.length;\n\n            var i, j, row, item, len2, vNew;\n\n            dflt = Array.isArray(dflt) ? dflt : [];\n\n            if(twoD) {\n                for(i = 0; i < len; i++) {\n                    vOut[i] = [];\n                    row = isArrayOrTypedArray(v[i]) ? v[i] : [];\n                    if(innerItemsOnly) len2 = items.length;\n                    else if(arrayItems) len2 = items[i].length;\n                    else len2 = row.length;\n\n                    for(j = 0; j < len2; j++) {\n                        if(innerItemsOnly) item = items[j];\n                        else if(arrayItems) item = items[i][j];\n                        else item = items;\n\n                        vNew = coercePart(row[j], item, (dflt[i] || [])[j]);\n                        if(vNew !== undefined) vOut[i][j] = vNew;\n                    }\n                }\n            } else {\n                for(i = 0; i < len; i++) {\n                    vNew = coercePart(v[i], arrayItems ? items[i] : items, dflt[i]);\n                    if(vNew !== undefined) vOut[i] = vNew;\n                }\n            }\n\n            propOut.set(vOut);\n        },\n        validateFunction: function(v, opts) {\n            if(!isArrayOrTypedArray(v)) return false;\n\n            var items = opts.items;\n            var arrayItems = Array.isArray(items);\n            var twoD = opts.dimensions === 2;\n\n            // when free length is off, input and declared lengths must match\n            if(!opts.freeLength && v.length !== items.length) return false;\n\n            // valid when all input items are valid\n            for(var i = 0; i < v.length; i++) {\n                if(twoD) {\n                    if(!isArrayOrTypedArray(v[i]) || (!opts.freeLength && v[i].length !== items[i].length)) {\n                        return false;\n                    }\n                    for(var j = 0; j < v[i].length; j++) {\n                        if(!validate(v[i][j], arrayItems ? items[i][j] : items)) {\n                            return false;\n                        }\n                    }\n                } else if(!validate(v[i], arrayItems ? items[i] : items)) return false;\n            }\n\n            return true;\n        }\n    }\n};\n\n/**\n * Ensures that container[attribute] has a valid value.\n *\n * attributes[attribute] is an object with possible keys:\n * - valType: data_array, enumerated, boolean, ... as in valObjectMeta\n * - values: (enumerated only) array of allowed vals\n * - min, max: (number, integer only) inclusive bounds on allowed vals\n *      either or both may be omitted\n * - dflt: if attribute is invalid or missing, use this default\n *      if dflt is provided as an argument to lib.coerce it takes precedence\n *      as a convenience, returns the value it finally set\n */\nexports.coerce = function(containerIn, containerOut, attributes, attribute, dflt) {\n    var opts = nestedProperty(attributes, attribute).get();\n    var propIn = nestedProperty(containerIn, attribute);\n    var propOut = nestedProperty(containerOut, attribute);\n    var v = propIn.get();\n\n    var template = containerOut._template;\n    if(v === undefined && template) {\n        v = nestedProperty(template, attribute).get();\n        // already used the template value, so short-circuit the second check\n        template = 0;\n    }\n\n    if(dflt === undefined) dflt = opts.dflt;\n\n    if(opts.arrayOk) {\n        if(isArrayOrTypedArray(v)) {\n            /**\n             * arrayOk: value MAY be an array, then we do no value checking\n             * at this point, because it can be more complicated than the\n             * individual form (eg. some array vals can be numbers, even if the\n             * single values must be color strings)\n             */\n\n            propOut.set(v);\n            return v;\n        } else {\n            if(isTypedArraySpec(v)) {\n                v = decodeTypedArraySpec(v);\n                propOut.set(v);\n                return v;\n            }\n        }\n    }\n\n    var coerceFunction = exports.valObjectMeta[opts.valType].coerceFunction;\n    coerceFunction(v, propOut, dflt, opts);\n\n    var out = propOut.get();\n    // in case v was provided but invalid, try the template again so it still\n    // overrides the regular default\n    if(template && out === dflt && !validate(v, opts)) {\n        v = nestedProperty(template, attribute).get();\n        coerceFunction(v, propOut, dflt, opts);\n        out = propOut.get();\n    }\n    return out;\n};\n\n/**\n * Variation on coerce\n *\n * Uses coerce to get attribute value if user input is valid,\n * returns attribute default if user input it not valid or\n * returns false if there is no user input.\n */\nexports.coerce2 = function(containerIn, containerOut, attributes, attribute, dflt) {\n    var propIn = nestedProperty(containerIn, attribute);\n    var propOut = exports.coerce(containerIn, containerOut, attributes, attribute, dflt);\n    var valIn = propIn.get();\n\n    return (valIn !== undefined && valIn !== null) ? propOut : false;\n};\n\n/*\n * Shortcut to coerce the three font attributes\n *\n * 'coerce' is a lib.coerce wrapper with implied first three arguments\n */\nexports.coerceFont = function(coerce, attr, dfltObj) {\n    var out = {};\n\n    dfltObj = dfltObj || {};\n\n    out.family = coerce(attr + '.family', dfltObj.family);\n    out.size = coerce(attr + '.size', dfltObj.size);\n    out.color = coerce(attr + '.color', dfltObj.color);\n\n    return out;\n};\n\n/*\n * Shortcut to coerce the pattern attributes\n */\nexports.coercePattern = function(coerce, attr, markerColor, hasMarkerColorscale) {\n    var shape = coerce(attr + '.shape');\n    if(shape) {\n        coerce(attr + '.solidity');\n        coerce(attr + '.size');\n        var fillmode = coerce(attr + '.fillmode');\n        var isOverlay = fillmode === 'overlay';\n\n        if(!hasMarkerColorscale) {\n            var bgcolor = coerce(attr + '.bgcolor', isOverlay ?\n                markerColor :\n                undefined\n            );\n\n            coerce(attr + '.fgcolor', isOverlay ?\n                Color.contrast(bgcolor) :\n                markerColor\n            );\n        }\n\n        coerce(attr + '.fgopacity', isOverlay ?\n            0.5 :\n            1\n        );\n    }\n};\n\n/** Coerce shortcut for 'hoverinfo'\n * handling 1-vs-multi-trace dflt logic\n *\n * @param {object} traceIn : user trace object\n * @param {object} traceOut : full trace object (requires _module ref)\n * @param {object} layoutOut : full layout object (require _dataLength ref)\n * @return {any} : the coerced value\n */\nexports.coerceHoverinfo = function(traceIn, traceOut, layoutOut) {\n    var moduleAttrs = traceOut._module.attributes;\n    var attrs = moduleAttrs.hoverinfo ? moduleAttrs : baseTraceAttrs;\n\n    var valObj = attrs.hoverinfo;\n    var dflt;\n\n    if(layoutOut._dataLength === 1) {\n        var flags = valObj.dflt === 'all' ?\n            valObj.flags.slice() :\n            valObj.dflt.split('+');\n\n        flags.splice(flags.indexOf('name'), 1);\n        dflt = flags.join('+');\n    }\n\n    return exports.coerce(traceIn, traceOut, attrs, 'hoverinfo', dflt);\n};\n\n/** Coerce shortcut for [un]selected.marker.opacity,\n *  which has special default logic, to ensure that it corresponds to the\n *  default selection behavior while allowing to be overtaken by any other\n *  [un]selected attribute.\n *\n *  N.B. This must be called *after* coercing all the other [un]selected attrs,\n *  to give the intended result.\n *\n * @param {object} traceOut : fullData item\n * @param {function} coerce : lib.coerce wrapper with implied first three arguments\n */\nexports.coerceSelectionMarkerOpacity = function(traceOut, coerce) {\n    if(!traceOut.marker) return;\n\n    var mo = traceOut.marker.opacity;\n    // you can still have a `marker` container with no markers if there's text\n    if(mo === undefined) return;\n\n    var smoDflt;\n    var usmoDflt;\n\n    // Don't give [un]selected.marker.opacity a default value if\n    // marker.opacity is an array: handle this during style step.\n    //\n    // Only give [un]selected.marker.opacity a default value if you don't\n    // set any other [un]selected attributes.\n    if(!isArrayOrTypedArray(mo) && !traceOut.selected && !traceOut.unselected) {\n        smoDflt = mo;\n        usmoDflt = DESELECTDIM * mo;\n    }\n\n    coerce('selected.marker.opacity', smoDflt);\n    coerce('unselected.marker.opacity', usmoDflt);\n};\n\nfunction validate(value, opts) {\n    var valObjectDef = exports.valObjectMeta[opts.valType];\n\n    if(opts.arrayOk && isArrayOrTypedArray(value)) return true;\n\n    if(valObjectDef.validateFunction) {\n        return valObjectDef.validateFunction(value, opts);\n    }\n\n    var failed = {};\n    var out = failed;\n    var propMock = { set: function(v) { out = v; } };\n\n    // 'failed' just something mutable that won't be === anything else\n\n    valObjectDef.coerceFunction(value, propMock, failed, opts);\n    return out !== failed;\n}\nexports.validate = validate;\n","'use strict';\n\nvar timeFormat = require('d3-time-format').timeFormat;\nvar isNumeric = require('fast-isnumeric');\n\nvar Loggers = require('./loggers');\nvar mod = require('./mod').mod;\n\nvar constants = require('../constants/numerical');\nvar BADNUM = constants.BADNUM;\nvar ONEDAY = constants.ONEDAY;\nvar ONEHOUR = constants.ONEHOUR;\nvar ONEMIN = constants.ONEMIN;\nvar ONESEC = constants.ONESEC;\nvar EPOCHJD = constants.EPOCHJD;\n\nvar Registry = require('../registry');\n\nvar utcFormat = require('d3-time-format').utcFormat;\n\nvar DATETIME_REGEXP = /^\\s*(-?\\d\\d\\d\\d|\\d\\d)(-(\\d?\\d)(-(\\d?\\d)([ Tt]([01]?\\d|2[0-3])(:([0-5]\\d)(:([0-5]\\d(\\.\\d+)?))?(Z|z|[+\\-]\\d\\d(:?\\d\\d)?)?)?)?)?)?\\s*$/m;\n// special regex for chinese calendars to support yyyy-mmi-dd etc for intercalary months\nvar DATETIME_REGEXP_CN = /^\\s*(-?\\d\\d\\d\\d|\\d\\d)(-(\\d?\\di?)(-(\\d?\\d)([ Tt]([01]?\\d|2[0-3])(:([0-5]\\d)(:([0-5]\\d(\\.\\d+)?))?(Z|z|[+\\-]\\d\\d(:?\\d\\d)?)?)?)?)?)?\\s*$/m;\n\n// for 2-digit years, the first year we map them onto\nvar YFIRST = new Date().getFullYear() - 70;\n\nfunction isWorldCalendar(calendar) {\n    return (\n        calendar &&\n        Registry.componentsRegistry.calendars &&\n        typeof calendar === 'string' && calendar !== 'gregorian'\n    );\n}\n\n/*\n * dateTick0: get the canonical tick for this calendar\n *\n * integer weekdays : Saturday: 0, Sunday: 1, Monday: 2, etc.\n */\nexports.dateTick0 = function(calendar, dayOfWeek) {\n    var tick0 = _dateTick0(calendar, !!dayOfWeek);\n    if(dayOfWeek < 2) return tick0;\n\n    var v = exports.dateTime2ms(tick0, calendar);\n    v += ONEDAY * (dayOfWeek - 1); // shift Sunday to Monday, etc.\n    return exports.ms2DateTime(v, 0, calendar);\n};\n\n/*\n * _dateTick0: get the canonical tick for this calendar\n *\n * bool sunday is for week ticks, shift it to a Sunday.\n */\nfunction _dateTick0(calendar, sunday) {\n    if(isWorldCalendar(calendar)) {\n        return sunday ?\n            Registry.getComponentMethod('calendars', 'CANONICAL_SUNDAY')[calendar] :\n            Registry.getComponentMethod('calendars', 'CANONICAL_TICK')[calendar];\n    } else {\n        return sunday ? '2000-01-02' : '2000-01-01';\n    }\n}\n\n/*\n * dfltRange: for each calendar, give a valid default range\n */\nexports.dfltRange = function(calendar) {\n    if(isWorldCalendar(calendar)) {\n        return Registry.getComponentMethod('calendars', 'DFLTRANGE')[calendar];\n    } else {\n        return ['2000-01-01', '2001-01-01'];\n    }\n};\n\n// is an object a javascript date?\nexports.isJSDate = function(v) {\n    return typeof v === 'object' && v !== null && typeof v.getTime === 'function';\n};\n\n// The absolute limits of our date-time system\n// This is a little weird: we use MIN_MS and MAX_MS in dateTime2ms\n// but we use dateTime2ms to calculate them (after defining it!)\nvar MIN_MS, MAX_MS;\n\n/**\n * dateTime2ms - turn a date object or string s into milliseconds\n * (relative to 1970-01-01, per javascript standard)\n * optional calendar (string) to use a non-gregorian calendar\n *\n * Returns BADNUM if it doesn't find a date\n *\n * strings should have the form:\n *\n *    -?YYYY-mm-dd<sep>HH:MM:SS.sss<tzInfo>?\n *\n * <sep>: space (our normal standard) or T or t (ISO-8601)\n * <tzInfo>: Z, z, [+\\-]HH:?MM or [+\\-]HH and we THROW IT AWAY\n * this format comes from https://tools.ietf.org/html/rfc3339#section-5.6\n * and 4.2.5.1 Difference between local time and UTC of day (ISO-8601)\n * but we allow it even with a space as the separator\n *\n * May truncate after any full field, and sss can be any length\n * even >3 digits, though javascript dates truncate to milliseconds,\n * we keep as much as javascript numeric precision can hold, but we only\n * report back up to 100 microsecond precision, because most dates support\n * this precision (close to 1970 support more, very far away support less)\n *\n * Expanded to support negative years to -9999 but you must always\n * give 4 digits, except for 2-digit positive years which we assume are\n * near the present time.\n * Note that we follow ISO 8601:2004: there *is* a year 0, which\n * is 1BC/BCE, and -1===2BC etc.\n *\n * World calendars: not all of these *have* agreed extensions to this full range,\n * if you have another calendar system but want a date range outside its validity,\n * you can use a gregorian date string prefixed with 'G' or 'g'.\n *\n * Where to cut off 2-digit years between 1900s and 2000s?\n * from https://docs.microsoft.com/en-us/office/troubleshoot/excel/two-digit-year-numbers#the-2029-rule:\n *   1930-2029 (the most retro of all...)\n * but in my mac chrome from eg. d=new Date(Date.parse('8/19/50')):\n *   1950-2049\n * by Java, from http://stackoverflow.com/questions/2024273/:\n *   now-80 - now+19\n * or FileMaker Pro, from\n *      https://fmhelp.filemaker.com/help/18/fmp/en/index.html#page/FMP_Help/dates-with-two-digit-years.html:\n *   now-70 - now+29\n * but python strptime etc, via\n *      http://docs.python.org/py3k/library/time.html:\n *   1969-2068 (super forward-looking, but static, not sliding!)\n *\n * lets go with now-70 to now+29, and if anyone runs into this problem\n * they can learn the hard way not to use 2-digit years, as no choice we\n * make now will cover all possibilities. mostly this will all be taken\n * care of in initial parsing, should only be an issue for hand-entered data\n * currently (2016) this range is:\n *   1946-2045\n */\nexports.dateTime2ms = function(s, calendar) {\n    // first check if s is a date object\n    if(exports.isJSDate(s)) {\n        // Convert to the UTC milliseconds that give the same\n        // hours as this date has in the local timezone\n        var tzOffset = s.getTimezoneOffset() * ONEMIN;\n        var offsetTweak = (s.getUTCMinutes() - s.getMinutes()) * ONEMIN +\n            (s.getUTCSeconds() - s.getSeconds()) * ONESEC +\n            (s.getUTCMilliseconds() - s.getMilliseconds());\n\n        if(offsetTweak) {\n            var comb = 3 * ONEMIN;\n            tzOffset = tzOffset - comb / 2 + mod(offsetTweak - tzOffset + comb / 2, comb);\n        }\n        s = Number(s) - tzOffset;\n        if(s >= MIN_MS && s <= MAX_MS) return s;\n        return BADNUM;\n    }\n    // otherwise only accept strings and numbers\n    if(typeof s !== 'string' && typeof s !== 'number') return BADNUM;\n\n    s = String(s);\n\n    var isWorld = isWorldCalendar(calendar);\n\n    // to handle out-of-range dates in international calendars, accept\n    // 'G' as a prefix to force the built-in gregorian calendar.\n    var s0 = s.charAt(0);\n    if(isWorld && (s0 === 'G' || s0 === 'g')) {\n        s = s.substr(1);\n        calendar = '';\n    }\n\n    var isChinese = isWorld && calendar.substr(0, 7) === 'chinese';\n\n    var match = s.match(isChinese ? DATETIME_REGEXP_CN : DATETIME_REGEXP);\n    if(!match) return BADNUM;\n    var y = match[1];\n    var m = match[3] || '1';\n    var d = Number(match[5] || 1);\n    var H = Number(match[7] || 0);\n    var M = Number(match[9] || 0);\n    var S = Number(match[11] || 0);\n\n    if(isWorld) {\n        // disallow 2-digit years for world calendars\n        if(y.length === 2) return BADNUM;\n        y = Number(y);\n\n        var cDate;\n        try {\n            var calInstance = Registry.getComponentMethod('calendars', 'getCal')(calendar);\n            if(isChinese) {\n                var isIntercalary = m.charAt(m.length - 1) === 'i';\n                m = parseInt(m, 10);\n                cDate = calInstance.newDate(y, calInstance.toMonthIndex(y, m, isIntercalary), d);\n            } else {\n                cDate = calInstance.newDate(y, Number(m), d);\n            }\n        } catch(e) { return BADNUM; } // Invalid ... date\n\n        if(!cDate) return BADNUM;\n\n        return ((cDate.toJD() - EPOCHJD) * ONEDAY) +\n            (H * ONEHOUR) + (M * ONEMIN) + (S * ONESEC);\n    }\n\n    if(y.length === 2) {\n        y = (Number(y) + 2000 - YFIRST) % 100 + YFIRST;\n    } else y = Number(y);\n\n    // new Date uses months from 0; subtract 1 here just so we\n    // don't have to do it again during the validity test below\n    m -= 1;\n\n    // javascript takes new Date(0..99,m,d) to mean 1900-1999, so\n    // to support years 0-99 we need to use setFullYear explicitly\n    // Note that 2000 is a leap year.\n    var date = new Date(Date.UTC(2000, m, d, H, M));\n    date.setUTCFullYear(y);\n\n    if(date.getUTCMonth() !== m) return BADNUM;\n    if(date.getUTCDate() !== d) return BADNUM;\n\n    return date.getTime() + S * ONESEC;\n};\n\nMIN_MS = exports.MIN_MS = exports.dateTime2ms('-9999');\nMAX_MS = exports.MAX_MS = exports.dateTime2ms('9999-12-31 23:59:59.9999');\n\n// is string s a date? (see above)\nexports.isDateTime = function(s, calendar) {\n    return (exports.dateTime2ms(s, calendar) !== BADNUM);\n};\n\n// pad a number with zeroes, to given # of digits before the decimal point\nfunction lpad(val, digits) {\n    return String(val + Math.pow(10, digits)).substr(1);\n}\n\n/**\n * Turn ms into string of the form YYYY-mm-dd HH:MM:SS.ssss\n * Crop any trailing zeros in time, except never stop right after hours\n * (we could choose to crop '-01' from date too but for now we always\n * show the whole date)\n * Optional range r is the data range that applies, also in ms.\n * If rng is big, the later parts of time will be omitted\n */\nvar NINETYDAYS = 90 * ONEDAY;\nvar THREEHOURS = 3 * ONEHOUR;\nvar FIVEMIN = 5 * ONEMIN;\nexports.ms2DateTime = function(ms, r, calendar) {\n    if(typeof ms !== 'number' || !(ms >= MIN_MS && ms <= MAX_MS)) return BADNUM;\n\n    if(!r) r = 0;\n\n    var msecTenths = Math.floor(mod(ms + 0.05, 1) * 10);\n    var msRounded = Math.round(ms - msecTenths / 10);\n    var dateStr, h, m, s, msec10, d;\n\n    if(isWorldCalendar(calendar)) {\n        var dateJD = Math.floor(msRounded / ONEDAY) + EPOCHJD;\n        var timeMs = Math.floor(mod(ms, ONEDAY));\n        try {\n            dateStr = Registry.getComponentMethod('calendars', 'getCal')(calendar)\n                .fromJD(dateJD).formatDate('yyyy-mm-dd');\n        } catch(e) {\n            // invalid date in this calendar - fall back to Gyyyy-mm-dd\n            dateStr = utcFormat('G%Y-%m-%d')(new Date(msRounded));\n        }\n\n        // yyyy does NOT guarantee 4-digit years. YYYY mostly does, but does\n        // other things for a few calendars, so we can't trust it. Just pad\n        // it manually (after the '-' if there is one)\n        if(dateStr.charAt(0) === '-') {\n            while(dateStr.length < 11) dateStr = '-0' + dateStr.substr(1);\n        } else {\n            while(dateStr.length < 10) dateStr = '0' + dateStr;\n        }\n\n        // TODO: if this is faster, we could use this block for extracting\n        // the time components of regular gregorian too\n        h = (r < NINETYDAYS) ? Math.floor(timeMs / ONEHOUR) : 0;\n        m = (r < NINETYDAYS) ? Math.floor((timeMs % ONEHOUR) / ONEMIN) : 0;\n        s = (r < THREEHOURS) ? Math.floor((timeMs % ONEMIN) / ONESEC) : 0;\n        msec10 = (r < FIVEMIN) ? (timeMs % ONESEC) * 10 + msecTenths : 0;\n    } else {\n        d = new Date(msRounded);\n\n        dateStr = utcFormat('%Y-%m-%d')(d);\n\n        // <90 days: add hours and minutes - never *only* add hours\n        h = (r < NINETYDAYS) ? d.getUTCHours() : 0;\n        m = (r < NINETYDAYS) ? d.getUTCMinutes() : 0;\n        // <3 hours: add seconds\n        s = (r < THREEHOURS) ? d.getUTCSeconds() : 0;\n        // <5 minutes: add ms (plus one extra digit, this is msec*10)\n        msec10 = (r < FIVEMIN) ? d.getUTCMilliseconds() * 10 + msecTenths : 0;\n    }\n\n    return includeTime(dateStr, h, m, s, msec10);\n};\n\n// For converting old-style milliseconds to date strings,\n// we use the local timezone rather than UTC like we use\n// everywhere else, both for backward compatibility and\n// because that's how people mostly use javasript date objects.\n// Clip one extra day off our date range though so we can't get\n// thrown beyond the range by the timezone shift.\nexports.ms2DateTimeLocal = function(ms) {\n    if(!(ms >= MIN_MS + ONEDAY && ms <= MAX_MS - ONEDAY)) return BADNUM;\n\n    var msecTenths = Math.floor(mod(ms + 0.05, 1) * 10);\n    var d = new Date(Math.round(ms - msecTenths / 10));\n    var dateStr = timeFormat('%Y-%m-%d')(d);\n    var h = d.getHours();\n    var m = d.getMinutes();\n    var s = d.getSeconds();\n    var msec10 = d.getUTCMilliseconds() * 10 + msecTenths;\n\n    return includeTime(dateStr, h, m, s, msec10);\n};\n\nfunction includeTime(dateStr, h, m, s, msec10) {\n    // include each part that has nonzero data in or after it\n    if(h || m || s || msec10) {\n        dateStr += ' ' + lpad(h, 2) + ':' + lpad(m, 2);\n        if(s || msec10) {\n            dateStr += ':' + lpad(s, 2);\n            if(msec10) {\n                var digits = 4;\n                while(msec10 % 10 === 0) {\n                    digits -= 1;\n                    msec10 /= 10;\n                }\n                dateStr += '.' + lpad(msec10, digits);\n            }\n        }\n    }\n    return dateStr;\n}\n\n// normalize date format to date string, in case it starts as\n// a Date object or milliseconds\n// optional dflt is the return value if cleaning fails\nexports.cleanDate = function(v, dflt, calendar) {\n    // let us use cleanDate to provide a missing default without an error\n    if(v === BADNUM) return dflt;\n    if(exports.isJSDate(v) || (typeof v === 'number' && isFinite(v))) {\n        // do not allow milliseconds (old) or jsdate objects (inherently\n        // described as gregorian dates) with world calendars\n        if(isWorldCalendar(calendar)) {\n            Loggers.error('JS Dates and milliseconds are incompatible with world calendars', v);\n            return dflt;\n        }\n\n        // NOTE: if someone puts in a year as a number rather than a string,\n        // this will mistakenly convert it thinking it's milliseconds from 1970\n        // that is: '2012' -> Jan. 1, 2012, but 2012 -> 2012 epoch milliseconds\n        v = exports.ms2DateTimeLocal(+v);\n        if(!v && dflt !== undefined) return dflt;\n    } else if(!exports.isDateTime(v, calendar)) {\n        Loggers.error('unrecognized date', v);\n        return dflt;\n    }\n    return v;\n};\n\n/*\n *  Date formatting for ticks and hovertext\n */\n\n/*\n * modDateFormat: Support world calendars, and add two items to\n * d3's vocabulary:\n * %{n}f where n is the max number of digits of fractional seconds\n * %h formats: half of the year as a decimal number [1,2]\n */\nvar fracMatch = /%\\d?f/g;\nvar halfYearMatch = /%h/g;\nvar quarterToHalfYear = {\n    1: '1',\n    2: '1',\n    3: '2',\n    4: '2',\n};\nfunction modDateFormat(fmt, x, formatter, calendar) {\n    fmt = fmt.replace(fracMatch, function(match) {\n        var digits = Math.min(+(match.charAt(1)) || 6, 6);\n        var fracSecs = ((x / 1000 % 1) + 2)\n            .toFixed(digits)\n            .substr(2).replace(/0+$/, '') || '0';\n        return fracSecs;\n    });\n\n    var d = new Date(Math.floor(x + 0.05));\n\n    fmt = fmt.replace(halfYearMatch, function() {\n        return quarterToHalfYear[formatter('%q')(d)];\n    });\n\n    if(isWorldCalendar(calendar)) {\n        try {\n            fmt = Registry.getComponentMethod('calendars', 'worldCalFmt')(fmt, x, calendar);\n        } catch(e) {\n            return 'Invalid';\n        }\n    }\n    return formatter(fmt)(d);\n}\n\n/*\n * formatTime: create a time string from:\n *   x: milliseconds\n *   tr: tickround ('M', 'S', or # digits)\n * only supports UTC times (where every day is 24 hours and 0 is at midnight)\n */\nvar MAXSECONDS = [59, 59.9, 59.99, 59.999, 59.9999];\nfunction formatTime(x, tr) {\n    var timePart = mod(x + 0.05, ONEDAY);\n\n    var timeStr = lpad(Math.floor(timePart / ONEHOUR), 2) + ':' +\n        lpad(mod(Math.floor(timePart / ONEMIN), 60), 2);\n\n    if(tr !== 'M') {\n        if(!isNumeric(tr)) tr = 0; // should only be 'S'\n\n        /*\n         * this is a weird one - and shouldn't come up unless people\n         * monkey with tick0 in weird ways, but we need to do something!\n         * IN PARTICULAR we had better not display garbage (see below)\n         * for numbers we always round to the nearest increment of the\n         * precision we're showing, and this seems like the right way to\n         * handle seconds and milliseconds, as they have a decimal point\n         * and people will interpret that to mean rounding like numbers.\n         * but for larger increments we floor the value: it's always\n         * 2013 until the ball drops on the new year. We could argue about\n         * which field it is where we start rounding (should 12:08:59\n         * round to 12:09 if we're stopping at minutes?) but for now I'll\n         * say we round seconds but floor everything else. BUT that means\n         * we need to never round up to 60 seconds, ie 23:59:60\n         */\n        var sec = Math.min(mod(x / ONESEC, 60), MAXSECONDS[tr]);\n\n        var secStr = (100 + sec).toFixed(tr).substr(1);\n        if(tr > 0) {\n            secStr = secStr.replace(/0+$/, '').replace(/[\\.]$/, '');\n        }\n\n        timeStr += ':' + secStr;\n    }\n    return timeStr;\n}\n\n/*\n * formatDate: turn a date into tick or hover label text.\n *\n *   x: milliseconds, the value to convert\n *   fmt: optional, an explicit format string (d3 format, even for world calendars)\n *   tr: tickround ('y', 'm', 'd', 'M', 'S', or # digits)\n *      used if no explicit fmt is provided\n *   formatter: locale-aware d3 date formatter for standard gregorian calendars\n *      should be the result of exports.getD3DateFormat(gd)\n *   calendar: optional string, the world calendar system to use\n *\n * returns the date/time as a string, potentially with the leading portion\n * on a separate line (after '\\n')\n * Note that this means if you provide an explicit format which includes '\\n'\n * the axis may choose to strip things after it when they don't change from\n * one tick to the next (as it does with automatic formatting)\n */\nexports.formatDate = function(x, fmt, tr, formatter, calendar, extraFormat) {\n    calendar = isWorldCalendar(calendar) && calendar;\n\n    if(!fmt) {\n        if(tr === 'y') fmt = extraFormat.year;\n        else if(tr === 'm') fmt = extraFormat.month;\n        else if(tr === 'd') {\n            fmt = extraFormat.dayMonth + '\\n' + extraFormat.year;\n        } else {\n            return formatTime(x, tr) + '\\n' + modDateFormat(extraFormat.dayMonthYear, x, formatter, calendar);\n        }\n    }\n\n    return modDateFormat(fmt, x, formatter, calendar);\n};\n\n/*\n * incrementMonth: make a new milliseconds value from the given one,\n * having changed the month\n *\n * special case for world calendars: multiples of 12 are treated as years,\n * even for calendar systems that don't have (always or ever) 12 months/year\n * TODO: perhaps we need a different code for year increments to support this?\n *\n * ms (number): the initial millisecond value\n * dMonth (int): the (signed) number of months to shift\n * calendar (string): the calendar system to use\n *\n * changing month does not (and CANNOT) always preserve day, since\n * months have different lengths. The worst example of this is:\n *   d = new Date(1970,0,31); d.setMonth(1) -> Feb 31 turns into Mar 3\n *\n * But we want to be able to iterate over the last day of each month,\n * regardless of what its number is.\n * So shift 3 days forward, THEN set the new month, then unshift:\n *   1/31 -> 2/28 (or 29) -> 3/31 -> 4/30 -> ...\n *\n * Note that odd behavior still exists if you start from the 26th-28th:\n *   1/28 -> 2/28 -> 3/31\n * but at least you can't shift any dates into the wrong month,\n * and ticks on these days incrementing by month would be very unusual\n */\nvar THREEDAYS = 3 * ONEDAY;\nexports.incrementMonth = function(ms, dMonth, calendar) {\n    calendar = isWorldCalendar(calendar) && calendar;\n\n    // pull time out and operate on pure dates, then add time back at the end\n    // this gives maximum precision - not that we *normally* care if we're\n    // incrementing by month, but better to be safe!\n    var timeMs = mod(ms, ONEDAY);\n    ms = Math.round(ms - timeMs);\n\n    if(calendar) {\n        try {\n            var dateJD = Math.round(ms / ONEDAY) + EPOCHJD;\n            var calInstance = Registry.getComponentMethod('calendars', 'getCal')(calendar);\n            var cDate = calInstance.fromJD(dateJD);\n\n            if(dMonth % 12) calInstance.add(cDate, dMonth, 'm');\n            else calInstance.add(cDate, dMonth / 12, 'y');\n\n            return (cDate.toJD() - EPOCHJD) * ONEDAY + timeMs;\n        } catch(e) {\n            Loggers.error('invalid ms ' + ms + ' in calendar ' + calendar);\n            // then keep going in gregorian even though the result will be 'Invalid'\n        }\n    }\n\n    var y = new Date(ms + THREEDAYS);\n    return y.setUTCMonth(y.getUTCMonth() + dMonth) + timeMs - THREEDAYS;\n};\n\n/*\n * findExactDates: what fraction of data is exact days, months, or years?\n *\n * data: array of millisecond values\n * calendar (string) the calendar to test against\n */\nexports.findExactDates = function(data, calendar) {\n    var exactYears = 0;\n    var exactMonths = 0;\n    var exactDays = 0;\n    var blankCount = 0;\n    var d;\n    var di;\n\n    var calInstance = (\n        isWorldCalendar(calendar) &&\n        Registry.getComponentMethod('calendars', 'getCal')(calendar)\n    );\n\n    for(var i = 0; i < data.length; i++) {\n        di = data[i];\n\n        // not date data at all\n        if(!isNumeric(di)) {\n            blankCount ++;\n            continue;\n        }\n\n        // not an exact date\n        if(di % ONEDAY) continue;\n\n        if(calInstance) {\n            try {\n                d = calInstance.fromJD(di / ONEDAY + EPOCHJD);\n                if(d.day() === 1) {\n                    if(d.month() === 1) exactYears++;\n                    else exactMonths++;\n                } else exactDays++;\n            } catch(e) {\n                // invalid date in this calendar - ignore it here.\n            }\n        } else {\n            d = new Date(di);\n            if(d.getUTCDate() === 1) {\n                if(d.getUTCMonth() === 0) exactYears++;\n                else exactMonths++;\n            } else exactDays++;\n        }\n    }\n    exactMonths += exactYears;\n    exactDays += exactMonths;\n\n    var dataCount = data.length - blankCount;\n\n    return {\n        exactYears: exactYears / dataCount,\n        exactMonths: exactMonths / dataCount,\n        exactDays: exactDays / dataCount\n    };\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar loggers = require('./loggers');\nvar matrix = require('./matrix');\nvar mat4X4 = require('gl-mat4');\n\n/**\n * Allow referencing a graph DOM element either directly\n * or by its id string\n *\n * @param {HTMLDivElement|string} gd: a graph element or its id\n *\n * @returns {HTMLDivElement} the DOM element of the graph\n */\nfunction getGraphDiv(gd) {\n    var gdElement;\n\n    if(typeof gd === 'string') {\n        gdElement = document.getElementById(gd);\n\n        if(gdElement === null) {\n            throw new Error('No DOM element with id \\'' + gd + '\\' exists on the page.');\n        }\n\n        return gdElement;\n    } else if(gd === null || gd === undefined) {\n        throw new Error('DOM element provided is null or undefined');\n    }\n\n    // otherwise assume that gd is a DOM element\n    return gd;\n}\n\nfunction isPlotDiv(el) {\n    var el3 = d3.select(el);\n    return el3.node() instanceof HTMLElement &&\n        el3.size() &&\n        el3.classed('js-plotly-plot');\n}\n\nfunction removeElement(el) {\n    var elParent = el && el.parentNode;\n    if(elParent) elParent.removeChild(el);\n}\n\n/**\n * for dynamically adding style rules\n * makes one stylesheet that contains all rules added\n * by all calls to this function\n */\nfunction addStyleRule(selector, styleString) {\n    addRelatedStyleRule('global', selector, styleString);\n}\n\n/**\n * for dynamically adding style rules\n * to a stylesheet uniquely identified by a uid\n */\nfunction addRelatedStyleRule(uid, selector, styleString) {\n    var id = 'plotly.js-style-' + uid;\n    var style = document.getElementById(id);\n    if(!style) {\n        style = document.createElement('style');\n        style.setAttribute('id', id);\n        // WebKit hack :(\n        style.appendChild(document.createTextNode(''));\n        document.head.appendChild(style);\n    }\n    var styleSheet = style.sheet;\n\n    if(styleSheet.insertRule) {\n        styleSheet.insertRule(selector + '{' + styleString + '}', 0);\n    } else if(styleSheet.addRule) {\n        styleSheet.addRule(selector, styleString, 0);\n    } else loggers.warn('addStyleRule failed');\n}\n\n/**\n * to remove from the page a stylesheet identified by a given uid\n */\nfunction deleteRelatedStyleRule(uid) {\n    var id = 'plotly.js-style-' + uid;\n    var style = document.getElementById(id);\n    if(style) removeElement(style);\n}\n\nfunction getFullTransformMatrix(element) {\n    var allElements = getElementAndAncestors(element);\n    // the identity matrix\n    var out = [\n        1, 0, 0, 0,\n        0, 1, 0, 0,\n        0, 0, 1, 0,\n        0, 0, 0, 1\n    ];\n    allElements.forEach(function(e) {\n        var t = getElementTransformMatrix(e);\n        if(t) {\n            var m = matrix.convertCssMatrix(t);\n            out = mat4X4.multiply(out, out, m);\n        }\n    });\n    return out;\n}\n\n/**\n * extracts and parses the 2d css style transform matrix from some element\n */\nfunction getElementTransformMatrix(element) {\n    var style = window.getComputedStyle(element, null);\n    var transform = (\n      style.getPropertyValue('-webkit-transform') ||\n      style.getPropertyValue('-moz-transform') ||\n      style.getPropertyValue('-ms-transform') ||\n      style.getPropertyValue('-o-transform') ||\n      style.getPropertyValue('transform')\n    );\n\n    if(transform === 'none') return null;\n    // the transform is a string in the form of matrix(a, b, ...) or matrix3d(...)\n    return transform\n        .replace('matrix', '')\n        .replace('3d', '')\n        .slice(1, -1)\n        .split(',')\n        .map(function(n) { return +n; });\n}\n/**\n * retrieve all DOM elements that are ancestors of the specified one (including itself)\n */\nfunction getElementAndAncestors(element) {\n    var allElements = [];\n    while(isTransformableElement(element)) {\n        allElements.push(element);\n        element = element.parentNode;\n    }\n    return allElements;\n}\n\nfunction isTransformableElement(element) {\n    return element && (element instanceof Element || element instanceof HTMLElement);\n}\n\nfunction equalDomRects(a, b) {\n    return (\n        a && b &&\n        a.top === b.top &&\n        a.left === b.left &&\n        a.right === b.right &&\n        a.bottom === b.bottom\n    );\n}\n\nmodule.exports = {\n    getGraphDiv: getGraphDiv,\n    isPlotDiv: isPlotDiv,\n    removeElement: removeElement,\n    addStyleRule: addStyleRule,\n    addRelatedStyleRule: addRelatedStyleRule,\n    deleteRelatedStyleRule: deleteRelatedStyleRule,\n    getFullTransformMatrix: getFullTransformMatrix,\n    getElementTransformMatrix: getElementTransformMatrix,\n    getElementAndAncestors: getElementAndAncestors,\n    equalDomRects: equalDomRects\n};\n","'use strict';\n\n/* global jQuery:false */\n\nvar EventEmitter = require('events').EventEmitter;\n\nvar Events = {\n\n    init: function(plotObj) {\n        /*\n         * If we have already instantiated an emitter for this plot\n         * return early.\n         */\n        if(plotObj._ev instanceof EventEmitter) return plotObj;\n\n        var ev = new EventEmitter();\n        var internalEv = new EventEmitter();\n\n        /*\n         * Assign to plot._ev while we still live in a land\n         * where plot is a DOM element with stuff attached to it.\n         * In the future we can make plot the event emitter itself.\n         */\n        plotObj._ev = ev;\n\n        /*\n         * Create a second event handler that will manage events *internally*.\n         * This allows parts of plotly to respond to thing like relayout without\n         * having to use the user-facing event handler. They cannot peacefully\n         * coexist on the same handler because a user invoking\n         * plotObj.removeAllListeners() would detach internal events, breaking\n         * plotly.\n         */\n        plotObj._internalEv = internalEv;\n\n        /*\n         * Assign bound methods from the ev to the plot object. These methods\n         * will reference the 'this' of plot._ev even though they are methods\n         * of plot. This will keep the event machinery away from the plot object\n         * which currently is often a DOM element but presents an API that will\n         * continue to function when plot becomes an emitter. Not all EventEmitter\n         * methods have been bound to `plot` as some do not currently add value to\n         * the Plotly event API.\n         */\n        plotObj.on = ev.on.bind(ev);\n        plotObj.once = ev.once.bind(ev);\n        plotObj.removeListener = ev.removeListener.bind(ev);\n        plotObj.removeAllListeners = ev.removeAllListeners.bind(ev);\n\n        /*\n         * Create functions for managing internal events. These are *only* triggered\n         * by the mirroring of external events via the emit function.\n         */\n        plotObj._internalOn = internalEv.on.bind(internalEv);\n        plotObj._internalOnce = internalEv.once.bind(internalEv);\n        plotObj._removeInternalListener = internalEv.removeListener.bind(internalEv);\n        plotObj._removeAllInternalListeners = internalEv.removeAllListeners.bind(internalEv);\n\n        /*\n         * We must wrap emit to continue to support JQuery events. The idea\n         * is to check to see if the user is using JQuery events, if they are\n         * we emit JQuery events to trigger user handlers as well as the EventEmitter\n         * events.\n         */\n        plotObj.emit = function(event, data) {\n            if(typeof jQuery !== 'undefined') {\n                jQuery(plotObj).trigger(event, data);\n            }\n\n            ev.emit(event, data);\n            internalEv.emit(event, data);\n        };\n\n        return plotObj;\n    },\n\n    /*\n     * This function behaves like jQuery's triggerHandler. It calls\n     * all handlers for a particular event and returns the return value\n     * of the LAST handler. This function also triggers jQuery's\n     * triggerHandler for backwards compatibility.\n     */\n    triggerHandler: function(plotObj, event, data) {\n        var jQueryHandlerValue;\n        var nodeEventHandlerValue;\n\n        /*\n         * If jQuery exists run all its handlers for this event and\n         * collect the return value of the LAST handler function\n         */\n        if(typeof jQuery !== 'undefined') {\n            jQueryHandlerValue = jQuery(plotObj).triggerHandler(event, data);\n        }\n\n        /*\n         * Now run all the node style event handlers\n         */\n        var ev = plotObj._ev;\n        if(!ev) return jQueryHandlerValue;\n\n        var handlers = ev._events[event];\n        if(!handlers) return jQueryHandlerValue;\n\n        // making sure 'this' is the EventEmitter instance\n        function apply(handler) {\n            // The 'once' case, we can't just call handler() as we need\n            // the return value here. So,\n            // - remove handler\n            // - call listener and grab return value!\n            // - stash 'fired' key to not call handler twice\n            if(handler.listener) {\n                ev.removeListener(event, handler.listener);\n                if(!handler.fired) {\n                    handler.fired = true;\n                    return handler.listener.apply(ev, [data]);\n                }\n            } else {\n                return handler.apply(ev, [data]);\n            }\n        }\n\n        // handlers can be function or an array of functions\n        handlers = Array.isArray(handlers) ? handlers : [handlers];\n\n        var i;\n        for(i = 0; i < handlers.length - 1; i++) {\n            apply(handlers[i]);\n        }\n        // now call the final handler and collect its value\n        nodeEventHandlerValue = apply(handlers[i]);\n\n        /*\n         * Return either the jQuery handler value if it exists or the\n         * nodeEventHandler value. jQuery event value supersedes nodejs\n         * events for backwards compatibility reasons.\n         */\n        return jQueryHandlerValue !== undefined ?\n            jQueryHandlerValue :\n            nodeEventHandlerValue;\n    },\n\n    purge: function(plotObj) {\n        delete plotObj._ev;\n        delete plotObj.on;\n        delete plotObj.once;\n        delete plotObj.removeListener;\n        delete plotObj.removeAllListeners;\n        delete plotObj.emit;\n\n        delete plotObj._ev;\n        delete plotObj._internalEv;\n        delete plotObj._internalOn;\n        delete plotObj._internalOnce;\n        delete plotObj._removeInternalListener;\n        delete plotObj._removeAllInternalListeners;\n\n        return plotObj;\n    }\n\n};\n\nmodule.exports = Events;\n","'use strict';\n\nvar isPlainObject = require('./is_plain_object.js');\nvar isArray = Array.isArray;\n\nfunction primitivesLoopSplice(source, target) {\n    var i, value;\n    for(i = 0; i < source.length; i++) {\n        value = source[i];\n        if(value !== null && typeof(value) === 'object') {\n            return false;\n        }\n        if(value !== void(0)) {\n            target[i] = value;\n        }\n    }\n    return true;\n}\n\nexports.extendFlat = function() {\n    return _extend(arguments, false, false, false);\n};\n\nexports.extendDeep = function() {\n    return _extend(arguments, true, false, false);\n};\n\nexports.extendDeepAll = function() {\n    return _extend(arguments, true, true, false);\n};\n\nexports.extendDeepNoArrays = function() {\n    return _extend(arguments, true, false, true);\n};\n\n/*\n * Inspired by https://github.com/justmoon/node-extend/blob/master/index.js\n * All credit to the jQuery authors for perfecting this amazing utility.\n *\n * API difference with jQuery version:\n * - No optional boolean (true -> deep extend) first argument,\n *   use `extendFlat` for first-level only extend and\n *   use `extendDeep` for a deep extend.\n *\n * Other differences with jQuery version:\n * - Uses a modern (and faster) isPlainObject routine.\n * - Expected to work with object {} and array [] arguments only.\n * - Does not check for circular structure.\n *   FYI: jQuery only does a check across one level.\n *   Warning: this might result in infinite loops.\n *\n */\nfunction _extend(inputs, isDeep, keepAllKeys, noArrayCopies) {\n    var target = inputs[0];\n    var length = inputs.length;\n\n    var input, key, src, copy, copyIsArray, clone, allPrimitives;\n\n    // TODO does this do the right thing for typed arrays?\n\n    if(length === 2 && isArray(target) && isArray(inputs[1]) && target.length === 0) {\n        allPrimitives = primitivesLoopSplice(inputs[1], target);\n\n        if(allPrimitives) {\n            return target;\n        } else {\n            target.splice(0, target.length); // reset target and continue to next block\n        }\n    }\n\n    for(var i = 1; i < length; i++) {\n        input = inputs[i];\n\n        for(key in input) {\n            src = target[key];\n            copy = input[key];\n\n            if(noArrayCopies && isArray(copy)) {\n                // Stop early and just transfer the array if array copies are disallowed:\n\n                target[key] = copy;\n            } else if(isDeep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n                // recurse if we're merging plain objects or arrays\n\n                if(copyIsArray) {\n                    copyIsArray = false;\n                    clone = src && isArray(src) ? src : [];\n                } else {\n                    clone = src && isPlainObject(src) ? src : {};\n                }\n\n                // never move original objects, clone them\n                target[key] = _extend([clone, copy], isDeep, keepAllKeys, noArrayCopies);\n            } else if(typeof copy !== 'undefined' || keepAllKeys) {\n                // don't bring in undefined values, except for extendDeepAll\n\n                target[key] = copy;\n            }\n        }\n    }\n\n    return target;\n}\n","'use strict';\n\n\n/**\n * Return news array containing only the unique items\n * found in input array.\n *\n * IMPORTANT: Note that items are considered unique\n * if `String({})` is unique. For example;\n *\n *  Lib.filterUnique([ { a: 1 }, { b: 2 } ])\n *\n *  returns [{ a: 1 }]\n *\n * and\n *\n *  Lib.filterUnique([ '1', 1 ])\n *\n *  returns ['1']\n *\n *\n * @param {array} array base array\n * @return {array} new filtered array\n */\nmodule.exports = function filterUnique(array) {\n    var seen = {};\n    var out = [];\n    var j = 0;\n\n    for(var i = 0; i < array.length; i++) {\n        var item = array[i];\n\n        if(seen[item] !== 1) {\n            seen[item] = 1;\n            out[j++] = item;\n        }\n    }\n\n    return out;\n};\n","'use strict';\n\n/** Filter out object items with visible !== true\n *  insider array container.\n *\n *  @param {array of objects} container\n *  @return {array of objects} of length <= container\n *\n */\nmodule.exports = function filterVisible(container) {\n    var filterFn = isCalcData(container) ? calcDataFilter : baseFilter;\n    var out = [];\n\n    for(var i = 0; i < container.length; i++) {\n        var item = container[i];\n        if(filterFn(item)) out.push(item);\n    }\n\n    return out;\n};\n\nfunction baseFilter(item) {\n    return item.visible === true;\n}\n\nfunction calcDataFilter(item) {\n    var trace = item[0].trace;\n    return trace.visible === true && trace._length !== 0;\n}\n\nfunction isCalcData(cont) {\n    return (\n        Array.isArray(cont) &&\n        Array.isArray(cont[0]) &&\n        cont[0][0] &&\n        cont[0][0].trace\n    );\n}\n","'use strict';\n\nvar mod = require('./mod').mod;\n\n/*\n * look for intersection of two line segments\n *   (1->2 and 3->4) - returns array [x,y] if they do, null if not\n */\nexports.segmentsIntersect = segmentsIntersect;\nfunction segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4) {\n    var a = x2 - x1;\n    var b = x3 - x1;\n    var c = x4 - x3;\n    var d = y2 - y1;\n    var e = y3 - y1;\n    var f = y4 - y3;\n    var det = a * f - c * d;\n    // parallel lines? intersection is undefined\n    // ignore the case where they are colinear\n    if(det === 0) return null;\n    var t = (b * f - c * e) / det;\n    var u = (b * d - a * e) / det;\n    // segments do not intersect?\n    if(u < 0 || u > 1 || t < 0 || t > 1) return null;\n\n    return {x: x1 + a * t, y: y1 + d * t};\n}\n\n/*\n * find the minimum distance between two line segments (1->2 and 3->4)\n */\nexports.segmentDistance = function segmentDistance(x1, y1, x2, y2, x3, y3, x4, y4) {\n    if(segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)) return 0;\n\n    // the two segments and their lengths squared\n    var x12 = x2 - x1;\n    var y12 = y2 - y1;\n    var x34 = x4 - x3;\n    var y34 = y4 - y3;\n    var ll12 = x12 * x12 + y12 * y12;\n    var ll34 = x34 * x34 + y34 * y34;\n\n    // calculate distance squared, then take the sqrt at the very end\n    var dist2 = Math.min(\n        perpDistance2(x12, y12, ll12, x3 - x1, y3 - y1),\n        perpDistance2(x12, y12, ll12, x4 - x1, y4 - y1),\n        perpDistance2(x34, y34, ll34, x1 - x3, y1 - y3),\n        perpDistance2(x34, y34, ll34, x2 - x3, y2 - y3)\n    );\n\n    return Math.sqrt(dist2);\n};\n\n/*\n * distance squared from segment ab to point c\n * [xab, yab] is the vector b-a\n * [xac, yac] is the vector c-a\n * llab is the length squared of (b-a), just to simplify calculation\n */\nfunction perpDistance2(xab, yab, llab, xac, yac) {\n    var fcAB = (xac * xab + yac * yab);\n    if(fcAB < 0) {\n        // point c is closer to point a\n        return xac * xac + yac * yac;\n    } else if(fcAB > llab) {\n        // point c is closer to point b\n        var xbc = xac - xab;\n        var ybc = yac - yab;\n        return xbc * xbc + ybc * ybc;\n    } else {\n        // perpendicular distance is the shortest\n        var crossProduct = xac * yab - yac * xab;\n        return crossProduct * crossProduct / llab;\n    }\n}\n\n// a very short-term cache for getTextLocation, just because\n// we're often looping over the same locations multiple times\n// invalidated as soon as we look at a different path\nvar locationCache, workingPath, workingTextWidth;\n\n// turn a path and position along it into x, y, and angle for the given text\nexports.getTextLocation = function getTextLocation(path, totalPathLen, positionOnPath, textWidth) {\n    if(path !== workingPath || textWidth !== workingTextWidth) {\n        locationCache = {};\n        workingPath = path;\n        workingTextWidth = textWidth;\n    }\n    if(locationCache[positionOnPath]) {\n        return locationCache[positionOnPath];\n    }\n\n    // for the angle, use points on the path separated by the text width\n    // even though due to curvature, the text will cover a bit more than that\n    var p0 = path.getPointAtLength(mod(positionOnPath - textWidth / 2, totalPathLen));\n    var p1 = path.getPointAtLength(mod(positionOnPath + textWidth / 2, totalPathLen));\n    // note: atan handles 1/0 nicely\n    var theta = Math.atan((p1.y - p0.y) / (p1.x - p0.x));\n    // center the text at 2/3 of the center position plus 1/3 the p0/p1 midpoint\n    // that's the average position of this segment, assuming it's roughly quadratic\n    var pCenter = path.getPointAtLength(mod(positionOnPath, totalPathLen));\n    var x = (pCenter.x * 4 + p0.x + p1.x) / 6;\n    var y = (pCenter.y * 4 + p0.y + p1.y) / 6;\n\n    var out = {x: x, y: y, theta: theta};\n    locationCache[positionOnPath] = out;\n    return out;\n};\n\nexports.clearLocationCache = function() {\n    workingPath = null;\n};\n\n/*\n * Find the segment of `path` that's within the visible area\n * given by `bounds` {left, right, top, bottom}, to within a\n * precision of `buffer` px\n *\n * returns: undefined if nothing is visible, else object:\n * {\n *   min: position where the path first enters bounds, or 0 if it\n *        starts within bounds\n *   max: position where the path last exits bounds, or the path length\n *        if it finishes within bounds\n *   len: max - min, ie the length of visible path\n *   total: the total path length - just included so the caller doesn't\n *        need to call path.getTotalLength() again\n *   isClosed: true iff the start and end points of the path are both visible\n *        and are at the same point\n * }\n *\n * Works by starting from either end and repeatedly finding the distance from\n * that point to the plot area, and if it's outside the plot, moving along the\n * path by that distance (because the plot must be at least that far away on\n * the path). Note that if a path enters, exits, and re-enters the plot, we\n * will not capture this behavior.\n */\nexports.getVisibleSegment = function getVisibleSegment(path, bounds, buffer) {\n    var left = bounds.left;\n    var right = bounds.right;\n    var top = bounds.top;\n    var bottom = bounds.bottom;\n\n    var pMin = 0;\n    var pTotal = path.getTotalLength();\n    var pMax = pTotal;\n\n    var pt0, ptTotal;\n\n    function getDistToPlot(len) {\n        var pt = path.getPointAtLength(len);\n\n        // hold on to the start and end points for `closed`\n        if(len === 0) pt0 = pt;\n        else if(len === pTotal) ptTotal = pt;\n\n        var dx = (pt.x < left) ? left - pt.x : (pt.x > right ? pt.x - right : 0);\n        var dy = (pt.y < top) ? top - pt.y : (pt.y > bottom ? pt.y - bottom : 0);\n        return Math.sqrt(dx * dx + dy * dy);\n    }\n\n    var distToPlot = getDistToPlot(pMin);\n    while(distToPlot) {\n        pMin += distToPlot + buffer;\n        if(pMin > pMax) return;\n        distToPlot = getDistToPlot(pMin);\n    }\n\n    distToPlot = getDistToPlot(pMax);\n    while(distToPlot) {\n        pMax -= distToPlot + buffer;\n        if(pMin > pMax) return;\n        distToPlot = getDistToPlot(pMax);\n    }\n\n    return {\n        min: pMin,\n        max: pMax,\n        len: pMax - pMin,\n        total: pTotal,\n        isClosed: pMin === 0 && pMax === pTotal &&\n            Math.abs(pt0.x - ptTotal.x) < 0.1 &&\n            Math.abs(pt0.y - ptTotal.y) < 0.1\n    };\n};\n\n/**\n * Find point on SVG path corresponding to a given constraint coordinate\n *\n * @param {SVGPathElement} path\n * @param {Number} val : constraint coordinate value\n * @param {String} coord : 'x' or 'y' the constraint coordinate\n * @param {Object} opts :\n *  - {Number} pathLength : supply total path length before hand\n *  - {Number} tolerance\n *  - {Number} iterationLimit\n * @return {SVGPoint}\n */\nexports.findPointOnPath = function findPointOnPath(path, val, coord, opts) {\n    opts = opts || {};\n\n    var pathLength = opts.pathLength || path.getTotalLength();\n    var tolerance = opts.tolerance || 1e-3;\n    var iterationLimit = opts.iterationLimit || 30;\n\n    // if path starts at a val greater than the path tail (like on vertical violins),\n    // we must flip the sign of the computed diff.\n    var mul = path.getPointAtLength(0)[coord] > path.getPointAtLength(pathLength)[coord] ? -1 : 1;\n\n    var i = 0;\n    var b0 = 0;\n    var b1 = pathLength;\n    var mid;\n    var pt;\n    var diff;\n\n    while(i < iterationLimit) {\n        mid = (b0 + b1) / 2;\n        pt = path.getPointAtLength(mid);\n        diff = pt[coord] - val;\n\n        if(Math.abs(diff) < tolerance) {\n            return pt;\n        } else {\n            if(mul * diff > 0) {\n                b1 = mid;\n            } else {\n                b0 = mid;\n            }\n            i++;\n        }\n    }\n    return pt;\n};\n","'use strict';\n\n// Simple helper functions\n// none of these need any external deps\n\nmodule.exports = function identity(d) { return d; };\n","'use strict';\n\nmodule.exports = function incrementNumeric(x, delta) {\n    if(!delta) return x;\n\n    // Note 1:\n    // 0.3 != 0.1 + 0.2 == 0.30000000000000004\n    // but 0.3 == (10 * 0.1 + 10 * 0.2) / 10\n    // Attempt to use integer steps to increment\n    var scale = 1 / Math.abs(delta);\n    var newX = (scale > 1) ? (\n        scale * x +\n        scale * delta\n    ) / scale : x + delta;\n\n    // Note 2:\n    // now we may also consider rounding to cover few more edge cases\n    // e.g. 0.3 * 3 = 0.8999999999999999\n    var lenX1 = String(newX).length;\n    if(lenX1 > 16) {\n        var lenDt = String(delta).length;\n        var lenX0 = String(x).length;\n\n        if(lenX1 >= lenX0 + lenDt) { // likely a rounding error!\n            var s = parseFloat(newX).toPrecision(12);\n            if(s.indexOf('e+') === -1) newX = +s;\n        }\n    }\n\n    return newX;\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar utcFormat = require('d3-time-format').utcFormat;\nvar d3Format = require('d3-format').format;\nvar isNumeric = require('fast-isnumeric');\n\nvar numConstants = require('../constants/numerical');\nvar MAX_SAFE = numConstants.FP_SAFE;\nvar MIN_SAFE = -MAX_SAFE;\nvar BADNUM = numConstants.BADNUM;\n\nvar lib = module.exports = {};\n\nlib.adjustFormat = function adjustFormat(formatStr) {\n    if(\n        !formatStr ||\n        /^\\d[.]\\df/.test(formatStr) ||\n        /[.]\\d%/.test(formatStr)\n    ) return formatStr;\n\n    if(formatStr === '0.f') return '~f';\n    if(/^\\d%/.test(formatStr)) return '~%';\n    if(/^\\ds/.test(formatStr)) return '~s';\n\n    // try adding tilde to the start of format in order to trim\n    if(!(/^[~,.0$]/.test(formatStr)) && /[&fps]/.test(formatStr)) return '~' + formatStr;\n\n    return formatStr;\n};\n\nvar seenBadFormats = {};\nlib.warnBadFormat = function(f) {\n    var key = String(f);\n    if(!seenBadFormats[key]) {\n        seenBadFormats[key] = 1;\n        lib.warn('encountered bad format: \"' + key + '\"');\n    }\n};\n\nlib.noFormat = function(value) {\n    return String(value);\n};\n\nlib.numberFormat = function(formatStr) {\n    var fn;\n    try {\n        fn = d3Format(lib.adjustFormat(formatStr));\n    } catch(e) {\n        lib.warnBadFormat(formatStr);\n        return lib.noFormat;\n    }\n\n    return fn;\n};\n\nlib.nestedProperty = require('./nested_property');\nlib.keyedContainer = require('./keyed_container');\nlib.relativeAttr = require('./relative_attr');\nlib.isPlainObject = require('./is_plain_object');\nlib.toLogRange = require('./to_log_range');\nlib.relinkPrivateKeys = require('./relink_private');\n\nvar arrayModule = require('./array');\nlib.isArrayBuffer = arrayModule.isArrayBuffer;\nlib.isTypedArray = arrayModule.isTypedArray;\nlib.isArrayOrTypedArray = arrayModule.isArrayOrTypedArray;\nlib.isArray1D = arrayModule.isArray1D;\nlib.ensureArray = arrayModule.ensureArray;\nlib.concat = arrayModule.concat;\nlib.maxRowLength = arrayModule.maxRowLength;\nlib.minRowLength = arrayModule.minRowLength;\n\nvar modModule = require('./mod');\nlib.mod = modModule.mod;\nlib.modHalf = modModule.modHalf;\n\nvar coerceModule = require('./coerce');\nlib.valObjectMeta = coerceModule.valObjectMeta;\nlib.coerce = coerceModule.coerce;\nlib.coerce2 = coerceModule.coerce2;\nlib.coerceFont = coerceModule.coerceFont;\nlib.coercePattern = coerceModule.coercePattern;\nlib.coerceHoverinfo = coerceModule.coerceHoverinfo;\nlib.coerceSelectionMarkerOpacity = coerceModule.coerceSelectionMarkerOpacity;\nlib.validate = coerceModule.validate;\n\nvar datesModule = require('./dates');\nlib.dateTime2ms = datesModule.dateTime2ms;\nlib.isDateTime = datesModule.isDateTime;\nlib.ms2DateTime = datesModule.ms2DateTime;\nlib.ms2DateTimeLocal = datesModule.ms2DateTimeLocal;\nlib.cleanDate = datesModule.cleanDate;\nlib.isJSDate = datesModule.isJSDate;\nlib.formatDate = datesModule.formatDate;\nlib.incrementMonth = datesModule.incrementMonth;\nlib.dateTick0 = datesModule.dateTick0;\nlib.dfltRange = datesModule.dfltRange;\nlib.findExactDates = datesModule.findExactDates;\nlib.MIN_MS = datesModule.MIN_MS;\nlib.MAX_MS = datesModule.MAX_MS;\n\nvar searchModule = require('./search');\nlib.findBin = searchModule.findBin;\nlib.sorterAsc = searchModule.sorterAsc;\nlib.sorterDes = searchModule.sorterDes;\nlib.distinctVals = searchModule.distinctVals;\nlib.roundUp = searchModule.roundUp;\nlib.sort = searchModule.sort;\nlib.findIndexOfMin = searchModule.findIndexOfMin;\n\nlib.sortObjectKeys = require('./sort_object_keys');\n\nvar statsModule = require('./stats');\nlib.aggNums = statsModule.aggNums;\nlib.len = statsModule.len;\nlib.mean = statsModule.mean;\nlib.median = statsModule.median;\nlib.midRange = statsModule.midRange;\nlib.variance = statsModule.variance;\nlib.stdev = statsModule.stdev;\nlib.interp = statsModule.interp;\n\nvar matrixModule = require('./matrix');\nlib.init2dArray = matrixModule.init2dArray;\nlib.transposeRagged = matrixModule.transposeRagged;\nlib.dot = matrixModule.dot;\nlib.translationMatrix = matrixModule.translationMatrix;\nlib.rotationMatrix = matrixModule.rotationMatrix;\nlib.rotationXYMatrix = matrixModule.rotationXYMatrix;\nlib.apply3DTransform = matrixModule.apply3DTransform;\nlib.apply2DTransform = matrixModule.apply2DTransform;\nlib.apply2DTransform2 = matrixModule.apply2DTransform2;\nlib.convertCssMatrix = matrixModule.convertCssMatrix;\nlib.inverseTransformMatrix = matrixModule.inverseTransformMatrix;\n\nvar anglesModule = require('./angles');\nlib.deg2rad = anglesModule.deg2rad;\nlib.rad2deg = anglesModule.rad2deg;\nlib.angleDelta = anglesModule.angleDelta;\nlib.angleDist = anglesModule.angleDist;\nlib.isFullCircle = anglesModule.isFullCircle;\nlib.isAngleInsideSector = anglesModule.isAngleInsideSector;\nlib.isPtInsideSector = anglesModule.isPtInsideSector;\nlib.pathArc = anglesModule.pathArc;\nlib.pathSector = anglesModule.pathSector;\nlib.pathAnnulus = anglesModule.pathAnnulus;\n\nvar anchorUtils = require('./anchor_utils');\nlib.isLeftAnchor = anchorUtils.isLeftAnchor;\nlib.isCenterAnchor = anchorUtils.isCenterAnchor;\nlib.isRightAnchor = anchorUtils.isRightAnchor;\nlib.isTopAnchor = anchorUtils.isTopAnchor;\nlib.isMiddleAnchor = anchorUtils.isMiddleAnchor;\nlib.isBottomAnchor = anchorUtils.isBottomAnchor;\n\nvar geom2dModule = require('./geometry2d');\nlib.segmentsIntersect = geom2dModule.segmentsIntersect;\nlib.segmentDistance = geom2dModule.segmentDistance;\nlib.getTextLocation = geom2dModule.getTextLocation;\nlib.clearLocationCache = geom2dModule.clearLocationCache;\nlib.getVisibleSegment = geom2dModule.getVisibleSegment;\nlib.findPointOnPath = geom2dModule.findPointOnPath;\n\nvar extendModule = require('./extend');\nlib.extendFlat = extendModule.extendFlat;\nlib.extendDeep = extendModule.extendDeep;\nlib.extendDeepAll = extendModule.extendDeepAll;\nlib.extendDeepNoArrays = extendModule.extendDeepNoArrays;\n\nvar loggersModule = require('./loggers');\nlib.log = loggersModule.log;\nlib.warn = loggersModule.warn;\nlib.error = loggersModule.error;\n\nvar regexModule = require('./regex');\nlib.counterRegex = regexModule.counter;\n\nvar throttleModule = require('./throttle');\nlib.throttle = throttleModule.throttle;\nlib.throttleDone = throttleModule.done;\nlib.clearThrottle = throttleModule.clear;\n\nvar domModule = require('./dom');\nlib.getGraphDiv = domModule.getGraphDiv;\nlib.isPlotDiv = domModule.isPlotDiv;\nlib.removeElement = domModule.removeElement;\nlib.addStyleRule = domModule.addStyleRule;\nlib.addRelatedStyleRule = domModule.addRelatedStyleRule;\nlib.deleteRelatedStyleRule = domModule.deleteRelatedStyleRule;\nlib.getFullTransformMatrix = domModule.getFullTransformMatrix;\nlib.getElementTransformMatrix = domModule.getElementTransformMatrix;\nlib.getElementAndAncestors = domModule.getElementAndAncestors;\nlib.equalDomRects = domModule.equalDomRects;\n\nlib.clearResponsive = require('./clear_responsive');\nlib.preserveDrawingBuffer = require('./preserve_drawing_buffer');\n\nlib.makeTraceGroups = require('./make_trace_groups');\n\nlib._ = require('./localize');\n\nlib.notifier = require('./notifier');\n\nlib.filterUnique = require('./filter_unique');\nlib.filterVisible = require('./filter_visible');\nlib.pushUnique = require('./push_unique');\n\nlib.increment = require('./increment');\n\nlib.cleanNumber = require('./clean_number');\n\nlib.ensureNumber = function ensureNumber(v) {\n    if(!isNumeric(v)) return BADNUM;\n    v = Number(v);\n    return (v > MAX_SAFE || v < MIN_SAFE) ? BADNUM : v;\n};\n\n/**\n * Is v a valid array index? Accepts numeric strings as well as numbers.\n *\n * @param {any} v: the value to test\n * @param {Optional[integer]} len: the array length we are indexing\n *\n * @return {bool}: v is a valid array index\n */\nlib.isIndex = function(v, len) {\n    if(len !== undefined && v >= len) return false;\n    return isNumeric(v) && (v >= 0) && (v % 1 === 0);\n};\n\nlib.noop = require('./noop');\nlib.identity = require('./identity');\n\n/**\n * create an array of length 'cnt' filled with 'v' at all indices\n *\n * @param {any} v\n * @param {number} cnt\n * @return {array}\n */\nlib.repeat = function(v, cnt) {\n    var out = new Array(cnt);\n    for(var i = 0; i < cnt; i++) {\n        out[i] = v;\n    }\n    return out;\n};\n\n/**\n * swap x and y of the same attribute in container cont\n * specify attr with a ? in place of x/y\n * you can also swap other things than x/y by providing part1 and part2\n */\nlib.swapAttrs = function(cont, attrList, part1, part2) {\n    if(!part1) part1 = 'x';\n    if(!part2) part2 = 'y';\n    for(var i = 0; i < attrList.length; i++) {\n        var attr = attrList[i];\n        var xp = lib.nestedProperty(cont, attr.replace('?', part1));\n        var yp = lib.nestedProperty(cont, attr.replace('?', part2));\n        var temp = xp.get();\n        xp.set(yp.get());\n        yp.set(temp);\n    }\n};\n\n/**\n * SVG painter's algo worked around with reinsertion\n */\nlib.raiseToTop = function raiseToTop(elem) {\n    elem.parentNode.appendChild(elem);\n};\n\n/**\n * cancel a possibly pending transition; returned selection may be used by caller\n */\nlib.cancelTransition = function(selection) {\n    return selection.transition().duration(0);\n};\n\n// constrain - restrict a number v to be between v0 and v1\nlib.constrain = function(v, v0, v1) {\n    if(v0 > v1) return Math.max(v1, Math.min(v0, v));\n    return Math.max(v0, Math.min(v1, v));\n};\n\n/**\n * do two bounding boxes from getBoundingClientRect,\n * ie {left,right,top,bottom,width,height}, overlap?\n * takes optional padding pixels\n */\nlib.bBoxIntersect = function(a, b, pad) {\n    pad = pad || 0;\n    return (a.left <= b.right + pad &&\n            b.left <= a.right + pad &&\n            a.top <= b.bottom + pad &&\n            b.top <= a.bottom + pad);\n};\n\n/*\n * simpleMap: alternative to Array.map that only\n * passes on the element and up to 2 extra args you\n * provide (but not the array index or the whole array)\n *\n * array: the array to map it to\n * func: the function to apply\n * x1, x2: optional extra args\n */\nlib.simpleMap = function(array, func, x1, x2, opts) {\n    var len = array.length;\n    var out = new Array(len);\n    for(var i = 0; i < len; i++) out[i] = func(array[i], x1, x2, opts);\n    return out;\n};\n\n/**\n * Random string generator\n *\n * @param {object} existing\n *     pass in strings to avoid as keys with truthy values\n * @param {int} bits\n *     bits of information in the output string, default 24\n * @param {int} base\n *     base of string representation, default 16. Should be a power of 2.\n */\nlib.randstr = function randstr(existing, bits, base, _recursion) {\n    if(!base) base = 16;\n    if(bits === undefined) bits = 24;\n    if(bits <= 0) return '0';\n\n    var digits = Math.log(Math.pow(2, bits)) / Math.log(base);\n    var res = '';\n    var i, b, x;\n\n    for(i = 2; digits === Infinity; i *= 2) {\n        digits = Math.log(Math.pow(2, bits / i)) / Math.log(base) * i;\n    }\n\n    var rem = digits - Math.floor(digits);\n\n    for(i = 0; i < Math.floor(digits); i++) {\n        x = Math.floor(Math.random() * base).toString(base);\n        res = x + res;\n    }\n\n    if(rem) {\n        b = Math.pow(base, rem);\n        x = Math.floor(Math.random() * b).toString(base);\n        res = x + res;\n    }\n\n    var parsed = parseInt(res, base);\n    if((existing && existing[res]) ||\n         (parsed !== Infinity && parsed >= Math.pow(2, bits))) {\n        if(_recursion > 10) {\n            lib.warn('randstr failed uniqueness');\n            return res;\n        }\n        return randstr(existing, bits, base, (_recursion || 0) + 1);\n    } else return res;\n};\n\nlib.OptionControl = function(opt, optname) {\n    /*\n     * An environment to contain all option setters and\n     * getters that collectively modify opts.\n     *\n     * You can call up opts from any function in new object\n     * as this.optname || this.opt\n     *\n     * See FitOpts for example of usage\n     */\n    if(!opt) opt = {};\n    if(!optname) optname = 'opt';\n\n    var self = {};\n    self.optionList = [];\n\n    self._newoption = function(optObj) {\n        optObj[optname] = opt;\n        self[optObj.name] = optObj;\n        self.optionList.push(optObj);\n    };\n\n    self['_' + optname] = opt;\n    return self;\n};\n\n/**\n * lib.smooth: smooth arrayIn by convolving with\n * a hann window with given full width at half max\n * bounce the ends in, so the output has the same length as the input\n */\nlib.smooth = function(arrayIn, FWHM) {\n    FWHM = Math.round(FWHM) || 0; // only makes sense for integers\n    if(FWHM < 2) return arrayIn;\n\n    var alen = arrayIn.length;\n    var alen2 = 2 * alen;\n    var wlen = 2 * FWHM - 1;\n    var w = new Array(wlen);\n    var arrayOut = new Array(alen);\n    var i;\n    var j;\n    var k;\n    var v;\n\n    // first make the window array\n    for(i = 0; i < wlen; i++) {\n        w[i] = (1 - Math.cos(Math.PI * (i + 1) / FWHM)) / (2 * FWHM);\n    }\n\n    // now do the convolution\n    for(i = 0; i < alen; i++) {\n        v = 0;\n        for(j = 0; j < wlen; j++) {\n            k = i + j + 1 - FWHM;\n\n            // multibounce\n            if(k < -alen) k -= alen2 * Math.round(k / alen2);\n            else if(k >= alen2) k -= alen2 * Math.floor(k / alen2);\n\n            // single bounce\n            if(k < 0) k = - 1 - k;\n            else if(k >= alen) k = alen2 - 1 - k;\n\n            v += arrayIn[k] * w[j];\n        }\n        arrayOut[i] = v;\n    }\n\n    return arrayOut;\n};\n\n/**\n * syncOrAsync: run a sequence of functions synchronously\n * as long as its returns are not promises (ie have no .then)\n * includes one argument arg to send to all functions...\n * this is mainly just to prevent us having to make wrapper functions\n * when the only purpose of the wrapper is to reference gd\n * and a final step to be executed at the end\n * TODO: if there's an error and everything is sync,\n * this doesn't happen yet because we want to make sure\n * that it gets reported\n */\nlib.syncOrAsync = function(sequence, arg, finalStep) {\n    var ret, fni;\n\n    function continueAsync() {\n        return lib.syncOrAsync(sequence, arg, finalStep);\n    }\n\n    while(sequence.length) {\n        fni = sequence.splice(0, 1)[0];\n        ret = fni(arg);\n\n        if(ret && ret.then) {\n            return ret.then(continueAsync);\n        }\n    }\n\n    return finalStep && finalStep(arg);\n};\n\n\n/**\n * Helper to strip trailing slash, from\n * http://stackoverflow.com/questions/6680825/return-string-without-trailing-slash\n */\nlib.stripTrailingSlash = function(str) {\n    if(str.substr(-1) === '/') return str.substr(0, str.length - 1);\n    return str;\n};\n\nlib.noneOrAll = function(containerIn, containerOut, attrList) {\n    /**\n     * some attributes come together, so if you have one of them\n     * in the input, you should copy the default values of the others\n     * to the input as well.\n     */\n    if(!containerIn) return;\n\n    var hasAny = false;\n    var hasAll = true;\n    var i;\n    var val;\n\n    for(i = 0; i < attrList.length; i++) {\n        val = containerIn[attrList[i]];\n        if(val !== undefined && val !== null) hasAny = true;\n        else hasAll = false;\n    }\n\n    if(hasAny && !hasAll) {\n        for(i = 0; i < attrList.length; i++) {\n            containerIn[attrList[i]] = containerOut[attrList[i]];\n        }\n    }\n};\n\n/** merges calcdata field (given by cdAttr) with traceAttr values\n *\n * N.B. Loop over minimum of cd.length and traceAttr.length\n * i.e. it does not try to fill in beyond traceAttr.length-1\n *\n * @param {array} traceAttr : trace attribute\n * @param {object} cd : calcdata trace\n * @param {string} cdAttr : calcdata key\n */\nlib.mergeArray = function(traceAttr, cd, cdAttr, fn) {\n    var hasFn = typeof fn === 'function';\n    if(lib.isArrayOrTypedArray(traceAttr)) {\n        var imax = Math.min(traceAttr.length, cd.length);\n        for(var i = 0; i < imax; i++) {\n            var v = traceAttr[i];\n            cd[i][cdAttr] = hasFn ? fn(v) : v;\n        }\n    }\n};\n\n// cast numbers to positive numbers, returns 0 if not greater than 0\nlib.mergeArrayCastPositive = function(traceAttr, cd, cdAttr) {\n    return lib.mergeArray(traceAttr, cd, cdAttr, function(v) {\n        var w = +v;\n        return !isFinite(w) ? 0 : w > 0 ? w : 0;\n    });\n};\n\n/** fills calcdata field (given by cdAttr) with traceAttr values\n *  or function of traceAttr values (e.g. some fallback)\n *\n * N.B. Loops over all cd items.\n *\n * @param {array} traceAttr : trace attribute\n * @param {object} cd : calcdata trace\n * @param {string} cdAttr : calcdata key\n * @param {function} [fn] : optional function to apply to each array item\n */\nlib.fillArray = function(traceAttr, cd, cdAttr, fn) {\n    fn = fn || lib.identity;\n\n    if(lib.isArrayOrTypedArray(traceAttr)) {\n        for(var i = 0; i < cd.length; i++) {\n            cd[i][cdAttr] = fn(traceAttr[i]);\n        }\n    }\n};\n\n/** Handler for trace-wide vs per-point options\n *\n * @param {object} trace : (full) trace object\n * @param {number} ptNumber : index of the point in question\n * @param {string} astr : attribute string\n * @param {function} [fn] : optional function to apply to each array item\n *\n * @return {any}\n */\nlib.castOption = function(trace, ptNumber, astr, fn) {\n    fn = fn || lib.identity;\n\n    var val = lib.nestedProperty(trace, astr).get();\n\n    if(lib.isArrayOrTypedArray(val)) {\n        if(Array.isArray(ptNumber) && lib.isArrayOrTypedArray(val[ptNumber[0]])) {\n            return fn(val[ptNumber[0]][ptNumber[1]]);\n        } else {\n            return fn(val[ptNumber]);\n        }\n    } else {\n        return val;\n    }\n};\n\n/** Extract option from calcdata item, correctly falling back to\n *  trace value if not found.\n *\n *  @param {object} calcPt : calcdata[i][j] item\n *  @param {object} trace : (full) trace object\n *  @param {string} calcKey : calcdata key\n *  @param {string} traceKey : aka trace attribute string\n *  @return {any}\n */\nlib.extractOption = function(calcPt, trace, calcKey, traceKey) {\n    if(calcKey in calcPt) return calcPt[calcKey];\n\n    // fallback to trace value,\n    //   must check if value isn't itself an array\n    //   which means the trace attribute has a corresponding\n    //   calcdata key, but its value is falsy\n    var traceVal = lib.nestedProperty(trace, traceKey).get();\n    if(!Array.isArray(traceVal)) return traceVal;\n};\n\nfunction makePtIndex2PtNumber(indexToPoints) {\n    var ptIndex2ptNumber = {};\n    for(var k in indexToPoints) {\n        var pts = indexToPoints[k];\n        for(var j = 0; j < pts.length; j++) {\n            ptIndex2ptNumber[pts[j]] = +k;\n        }\n    }\n    return ptIndex2ptNumber;\n}\n\n/** Tag selected calcdata items\n *\n * N.B. note that point 'index' corresponds to input data array index\n *  whereas 'number' is its post-transform version.\n *\n * @param {array} calcTrace\n * @param {object} trace\n *  - selectedpoints {array}\n *  - _indexToPoints {object}\n * @param {ptNumber2cdIndex} ptNumber2cdIndex (optional)\n *  optional map object for trace types that do not have 1-to-1 point number to\n *  calcdata item index correspondence (e.g. histogram)\n */\nlib.tagSelected = function(calcTrace, trace, ptNumber2cdIndex) {\n    var selectedpoints = trace.selectedpoints;\n    var indexToPoints = trace._indexToPoints;\n    var ptIndex2ptNumber;\n\n    // make pt index-to-number map object, which takes care of transformed traces\n    if(indexToPoints) {\n        ptIndex2ptNumber = makePtIndex2PtNumber(indexToPoints);\n    }\n\n    function isCdIndexValid(v) {\n        return v !== undefined && v < calcTrace.length;\n    }\n\n    for(var i = 0; i < selectedpoints.length; i++) {\n        var ptIndex = selectedpoints[i];\n\n        if(lib.isIndex(ptIndex) ||\n           (lib.isArrayOrTypedArray(ptIndex) && lib.isIndex(ptIndex[0]) && lib.isIndex(ptIndex[1]))\n        ) {\n            var ptNumber = ptIndex2ptNumber ? ptIndex2ptNumber[ptIndex] : ptIndex;\n            var cdIndex = ptNumber2cdIndex ? ptNumber2cdIndex[ptNumber] : ptNumber;\n\n            if(isCdIndexValid(cdIndex)) {\n                calcTrace[cdIndex].selected = 1;\n            }\n        }\n    }\n};\n\nlib.selIndices2selPoints = function(trace) {\n    var selectedpoints = trace.selectedpoints;\n    var indexToPoints = trace._indexToPoints;\n\n    if(indexToPoints) {\n        var ptIndex2ptNumber = makePtIndex2PtNumber(indexToPoints);\n        var out = [];\n\n        for(var i = 0; i < selectedpoints.length; i++) {\n            var ptIndex = selectedpoints[i];\n            if(lib.isIndex(ptIndex)) {\n                var ptNumber = ptIndex2ptNumber[ptIndex];\n                if(lib.isIndex(ptNumber)) {\n                    out.push(ptNumber);\n                }\n            }\n        }\n\n        return out;\n    } else {\n        return selectedpoints;\n    }\n};\n\n/** Returns target as set by 'target' transform attribute\n *\n * @param {object} trace : full trace object\n * @param {object} transformOpts : transform option object\n *  - target (string} :\n *      either an attribute string referencing an array in the trace object, or\n *      a set array.\n *\n * @return {array or false} : the target array (NOT a copy!!) or false if invalid\n */\nlib.getTargetArray = function(trace, transformOpts) {\n    var target = transformOpts.target;\n\n    if(typeof target === 'string' && target) {\n        var array = lib.nestedProperty(trace, target).get();\n        return lib.isArrayOrTypedArray(array) ? array : false;\n    } else if(lib.isArrayOrTypedArray(target)) {\n        return target;\n    }\n\n    return false;\n};\n\n/**\n * modified version of jQuery's extend to strip out private objs and functions,\n * and cut arrays down to first <arraylen> or 1 elements\n * because extend-like algorithms are hella slow\n * obj2 is assumed to already be clean of these things (including no arrays)\n */\nfunction minExtend(obj1, obj2, opt) {\n    var objOut = {};\n    if(typeof obj2 !== 'object') obj2 = {};\n\n    var arrayLen = opt === 'pieLike' ? -1 : 3;\n\n    var keys = Object.keys(obj1);\n    var i, k, v;\n\n    for(i = 0; i < keys.length; i++) {\n        k = keys[i];\n        v = obj1[k];\n        if(k.charAt(0) === '_' || typeof v === 'function') continue;\n        else if(k === 'module') objOut[k] = v;\n        else if(Array.isArray(v)) {\n            if(k === 'colorscale' || arrayLen === -1) {\n                objOut[k] = v.slice();\n            } else {\n                objOut[k] = v.slice(0, arrayLen);\n            }\n        } else if(lib.isTypedArray(v)) {\n            if(arrayLen === -1) {\n                objOut[k] = v.subarray();\n            } else {\n                objOut[k] = v.subarray(0, arrayLen);\n            }\n        } else if(v && (typeof v === 'object')) objOut[k] = minExtend(obj1[k], obj2[k], opt);\n        else objOut[k] = v;\n    }\n\n    keys = Object.keys(obj2);\n    for(i = 0; i < keys.length; i++) {\n        k = keys[i];\n        v = obj2[k];\n        if(typeof v !== 'object' || !(k in objOut) || typeof objOut[k] !== 'object') {\n            objOut[k] = v;\n        }\n    }\n\n    return objOut;\n}\nlib.minExtend = minExtend;\n\nlib.titleCase = function(s) {\n    return s.charAt(0).toUpperCase() + s.substr(1);\n};\n\nlib.containsAny = function(s, fragments) {\n    for(var i = 0; i < fragments.length; i++) {\n        if(s.indexOf(fragments[i]) !== -1) return true;\n    }\n    return false;\n};\n\nlib.isIE = function() {\n    return typeof window.navigator.msSaveBlob !== 'undefined';\n};\n\nvar IS_SAFARI_REGEX = /Version\\/[\\d\\.]+.*Safari/;\nlib.isSafari = function() {\n    return IS_SAFARI_REGEX.test(window.navigator.userAgent);\n};\n\nvar IS_IOS_REGEX = /iPad|iPhone|iPod/;\nlib.isIOS = function() {\n    return IS_IOS_REGEX.test(window.navigator.userAgent);\n};\n\nvar FIREFOX_VERSION_REGEX = /Firefox\\/(\\d+)\\.\\d+/;\nlib.getFirefoxVersion = function() {\n    var match = FIREFOX_VERSION_REGEX.exec(window.navigator.userAgent);\n    if(match && match.length === 2) {\n        var versionInt = parseInt(match[1]);\n        if(!isNaN(versionInt)) {\n            return versionInt;\n        }\n    }\n    return null;\n};\n\nlib.isD3Selection = function(obj) {\n    return obj instanceof d3.selection;\n};\n\n/**\n * Append element to DOM only if not present.\n *\n * @param {d3 selection} parent : parent selection of the element in question\n * @param {string} nodeType : node type of element to append\n * @param {string} className (optional) : class name of element in question\n * @param {fn} enterFn (optional) : optional fn applied to entering elements only\n * @return {d3 selection} selection of new layer\n *\n * Previously, we were using the following pattern:\n *\n * ```\n * var sel = parent.selectAll('.' + className)\n *     .data([0]);\n *\n * sel.enter().append(nodeType)\n *     .classed(className, true);\n *\n * return sel;\n * ```\n *\n * in numerous places in our codebase to achieve the same behavior.\n *\n * The logic below performs much better, mostly as we are using\n * `.select` instead `.selectAll` that is `querySelector` instead of\n * `querySelectorAll`.\n *\n */\nlib.ensureSingle = function(parent, nodeType, className, enterFn) {\n    var sel = parent.select(nodeType + (className ? '.' + className : ''));\n    if(sel.size()) return sel;\n\n    var layer = parent.append(nodeType);\n    if(className) layer.classed(className, true);\n    if(enterFn) layer.call(enterFn);\n\n    return layer;\n};\n\n/**\n * Same as Lib.ensureSingle, but using id as selector.\n * This version is mostly used for clipPath nodes.\n *\n * @param {d3 selection} parent : parent selection of the element in question\n * @param {string} nodeType : node type of element to append\n * @param {string} id : id of element in question\n * @param {fn} enterFn (optional) : optional fn applied to entering elements only\n * @return {d3 selection} selection of new layer\n */\nlib.ensureSingleById = function(parent, nodeType, id, enterFn) {\n    var sel = parent.select(nodeType + '#' + id);\n    if(sel.size()) return sel;\n\n    var layer = parent.append(nodeType).attr('id', id);\n    if(enterFn) layer.call(enterFn);\n\n    return layer;\n};\n\n/**\n * Converts a string path to an object.\n *\n * When given a string containing an array element, it will create a `null`\n * filled array of the given size.\n *\n * @example\n * lib.objectFromPath('nested.test[2].path', 'value');\n * // returns { nested: { test: [null, null, { path: 'value' }]}\n *\n * @param   {string}    path to nested value\n * @param   {*}         any value to be set\n *\n * @return {Object} the constructed object with a full nested path\n */\nlib.objectFromPath = function(path, value) {\n    var keys = path.split('.');\n    var tmpObj;\n    var obj = tmpObj = {};\n\n    for(var i = 0; i < keys.length; i++) {\n        var key = keys[i];\n        var el = null;\n\n        var parts = keys[i].match(/(.*)\\[([0-9]+)\\]/);\n\n        if(parts) {\n            key = parts[1];\n            el = parts[2];\n\n            tmpObj = tmpObj[key] = [];\n\n            if(i === keys.length - 1) {\n                tmpObj[el] = value;\n            } else {\n                tmpObj[el] = {};\n            }\n\n            tmpObj = tmpObj[el];\n        } else {\n            if(i === keys.length - 1) {\n                tmpObj[key] = value;\n            } else {\n                tmpObj[key] = {};\n            }\n\n            tmpObj = tmpObj[key];\n        }\n    }\n\n    return obj;\n};\n\n/**\n * Iterate through an object in-place, converting dotted properties to objects.\n *\n * Examples:\n *\n *   lib.expandObjectPaths({'nested.test.path': 'value'});\n *     => { nested: { test: {path: 'value'}}}\n *\n * It also handles array notation, e.g.:\n *\n *   lib.expandObjectPaths({'foo[1].bar': 'value'});\n *     => { foo: [null, {bar: value}] }\n *\n * It handles merges the results when two properties are specified in parallel:\n *\n *   lib.expandObjectPaths({'foo[1].bar': 10, 'foo[0].bar': 20});\n *     => { foo: [{bar: 10}, {bar: 20}] }\n *\n * It does NOT, however, merge multiple multiply-nested arrays::\n *\n *   lib.expandObjectPaths({'marker[1].range[1]': 5, 'marker[1].range[0]': 4})\n *     => { marker: [null, {range: 4}] }\n */\n\n// Store this to avoid recompiling regex on *every* prop since this may happen many\n// many times for animations. Could maybe be inside the function. Not sure about\n// scoping vs. recompilation tradeoff, but at least it's not just inlining it into\n// the inner loop.\nvar dottedPropertyRegex = /^([^\\[\\.]+)\\.(.+)?/;\nvar indexedPropertyRegex = /^([^\\.]+)\\[([0-9]+)\\](\\.)?(.+)?/;\n\nfunction notValid(prop) {\n    // guard against polluting __proto__ and other internals getters and setters\n    return prop.slice(0, 2) === '__';\n}\n\nlib.expandObjectPaths = function(data) {\n    var match, key, prop, datum, idx, dest, trailingPath;\n    if(typeof data === 'object' && !Array.isArray(data)) {\n        for(key in data) {\n            if(data.hasOwnProperty(key)) {\n                if((match = key.match(dottedPropertyRegex))) {\n                    datum = data[key];\n                    prop = match[1];\n                    if(notValid(prop)) continue;\n\n                    delete data[key];\n\n                    data[prop] = lib.extendDeepNoArrays(data[prop] || {}, lib.objectFromPath(key, lib.expandObjectPaths(datum))[prop]);\n                } else if((match = key.match(indexedPropertyRegex))) {\n                    datum = data[key];\n\n                    prop = match[1];\n                    if(notValid(prop)) continue;\n\n                    idx = parseInt(match[2]);\n\n                    delete data[key];\n\n                    data[prop] = data[prop] || [];\n\n                    if(match[3] === '.') {\n                        // This is the case where theere are subsequent properties into which\n                        // we must recurse, e.g. transforms[0].value\n                        trailingPath = match[4];\n                        dest = data[prop][idx] = data[prop][idx] || {};\n\n                        // NB: Extend deep no arrays prevents this from working on multiple\n                        // nested properties in the same object, e.g.\n                        //\n                        // {\n                        //   foo[0].bar[1].range\n                        //   foo[0].bar[0].range\n                        // }\n                        //\n                        // In this case, the extendDeepNoArrays will overwrite one array with\n                        // the other, so that both properties *will not* be present in the\n                        // result. Fixing this would require a more intelligent tracking\n                        // of changes and merging than extendDeepNoArrays currently accomplishes.\n                        lib.extendDeepNoArrays(dest, lib.objectFromPath(trailingPath, lib.expandObjectPaths(datum)));\n                    } else {\n                        // This is the case where this property is the end of the line,\n                        // e.g. xaxis.range[0]\n\n                        if(notValid(prop)) continue;\n                        data[prop][idx] = lib.expandObjectPaths(datum);\n                    }\n                } else {\n                    if(notValid(key)) continue;\n                    data[key] = lib.expandObjectPaths(data[key]);\n                }\n            }\n        }\n    }\n\n    return data;\n};\n\n/**\n * Converts value to string separated by the provided separators.\n *\n * @example\n * lib.numSeparate(2016, '.,');\n * // returns '2016'\n *\n * @example\n * lib.numSeparate(3000, '.,', true);\n * // returns '3,000'\n *\n * @example\n * lib.numSeparate(1234.56, '|,')\n * // returns '1,234|56'\n *\n * @param   {string|number} value       the value to be converted\n * @param   {string}    separators  string of decimal, then thousands separators\n * @param   {boolean}    separatethousands  boolean, 4-digit integers are separated if true\n *\n * @return  {string}    the value that has been separated\n */\nlib.numSeparate = function(value, separators, separatethousands) {\n    if(!separatethousands) separatethousands = false;\n\n    if(typeof separators !== 'string' || separators.length === 0) {\n        throw new Error('Separator string required for formatting!');\n    }\n\n    if(typeof value === 'number') {\n        value = String(value);\n    }\n\n    var thousandsRe = /(\\d+)(\\d{3})/;\n    var decimalSep = separators.charAt(0);\n    var thouSep = separators.charAt(1);\n\n    var x = value.split('.');\n    var x1 = x[0];\n    var x2 = x.length > 1 ? decimalSep + x[1] : '';\n\n    // Years are ignored for thousands separators\n    if(thouSep && (x.length > 1 || x1.length > 4 || separatethousands)) {\n        while(thousandsRe.test(x1)) {\n            x1 = x1.replace(thousandsRe, '$1' + thouSep + '$2');\n        }\n    }\n\n    return x1 + x2;\n};\n\nlib.TEMPLATE_STRING_REGEX = /%{([^\\s%{}:]*)([:|\\|][^}]*)?}/g;\nvar SIMPLE_PROPERTY_REGEX = /^\\w*$/;\n\n/**\n * Substitute values from an object into a string\n *\n * Examples:\n *  Lib.templateString('name: %{trace}', {trace: 'asdf'}) --> 'name: asdf'\n *  Lib.templateString('name: %{trace[0].name}', {trace: [{name: 'asdf'}]}) --> 'name: asdf'\n *\n * @param {string}  input string containing %{...} template strings\n * @param {obj}     data object containing substitution values\n *\n * @return {string} templated string\n */\nlib.templateString = function(string, obj) {\n    // Not all that useful, but cache nestedProperty instantiation\n    // just in case it speeds things up *slightly*:\n    var getterCache = {};\n\n    return string.replace(lib.TEMPLATE_STRING_REGEX, function(dummy, key) {\n        var v;\n        if(SIMPLE_PROPERTY_REGEX.test(key)) {\n            v = obj[key];\n        } else {\n            getterCache[key] = getterCache[key] || lib.nestedProperty(obj, key).get;\n            v = getterCache[key]();\n        }\n        return lib.isValidTextValue(v) ? v : '';\n    });\n};\n\nvar hovertemplateWarnings = {\n    max: 10,\n    count: 0,\n    name: 'hovertemplate'\n};\nlib.hovertemplateString = function() {\n    return templateFormatString.apply(hovertemplateWarnings, arguments);\n};\n\nvar texttemplateWarnings = {\n    max: 10,\n    count: 0,\n    name: 'texttemplate'\n};\nlib.texttemplateString = function() {\n    return templateFormatString.apply(texttemplateWarnings, arguments);\n};\n\n// Regex for parsing multiplication and division operations applied to a template key\n// Used for shape.label.texttemplate\n// Matches a key name (non-whitespace characters), followed by a * or / character, followed by a number\n// For example, the following strings are matched: `x0*2`, `slope/1.60934`, `y1*2.54`\nvar MULT_DIV_REGEX = /^(\\S+)([\\*\\/])(-?\\d+(\\.\\d+)?)$/;\nfunction multDivParser(inputStr) {\n    var match = inputStr.match(MULT_DIV_REGEX);\n    if(match) return { key: match[1], op: match[2], number: Number(match[3]) };\n    return { key: inputStr, op: null, number: null };\n}\nvar texttemplateWarningsForShapes = {\n    max: 10,\n    count: 0,\n    name: 'texttemplate',\n    parseMultDiv: true,\n};\nlib.texttemplateStringForShapes = function() {\n    return templateFormatString.apply(texttemplateWarningsForShapes, arguments);\n};\n\nvar TEMPLATE_STRING_FORMAT_SEPARATOR = /^[:|\\|]/;\n/**\n * Substitute values from an object into a string and optionally formats them using d3-format,\n * or fallback to associated labels.\n *\n * Examples:\n *  Lib.hovertemplateString('name: %{trace}', {trace: 'asdf'}) --> 'name: asdf'\n *  Lib.hovertemplateString('name: %{trace[0].name}', {trace: [{name: 'asdf'}]}) --> 'name: asdf'\n *  Lib.hovertemplateString('price: %{y:$.2f}', {y: 1}) --> 'price: $1.00'\n *\n * @param {string}  input string containing %{...:...} template strings\n * @param {obj}     data object containing fallback text when no formatting is specified, ex.: {yLabel: 'formattedYValue'}\n * @param {obj}     d3 locale\n * @param {obj}     data objects containing substitution values\n *\n * @return {string} templated string\n */\nfunction templateFormatString(string, labels, d3locale) {\n    var opts = this;\n    var args = arguments;\n    if(!labels) labels = {};\n    // Not all that useful, but cache nestedProperty instantiation\n    // just in case it speeds things up *slightly*:\n    var getterCache = {};\n\n    return string.replace(lib.TEMPLATE_STRING_REGEX, function(match, rawKey, format) {\n        var isOther =\n            rawKey === 'xother' ||\n            rawKey === 'yother';\n\n        var isSpaceOther =\n            rawKey === '_xother' ||\n            rawKey === '_yother';\n\n        var isSpaceOtherSpace =\n            rawKey === '_xother_' ||\n            rawKey === '_yother_';\n\n        var isOtherSpace =\n            rawKey === 'xother_' ||\n            rawKey === 'yother_';\n\n        var hasOther = isOther || isSpaceOther || isOtherSpace || isSpaceOtherSpace;\n\n        var key = rawKey;\n        if(isSpaceOther || isSpaceOtherSpace) key = key.substring(1);\n        if(isOtherSpace || isSpaceOtherSpace) key = key.substring(0, key.length - 1);\n\n        // Shape labels support * and / operators in template string\n        // Parse these if the parseMultDiv param is set to true\n        var parsedOp = null;\n        var parsedNumber = null;\n        if(opts.parseMultDiv) {\n            var _match = multDivParser(key);\n            key = _match.key;\n            parsedOp = _match.op;\n            parsedNumber = _match.number;\n        }\n\n        var value;\n        if(hasOther) {\n            value = labels[key];\n            if(value === undefined) return '';\n        } else {\n            var obj, i;\n            for(i = 3; i < args.length; i++) {\n                obj = args[i];\n                if(!obj) continue;\n                if(obj.hasOwnProperty(key)) {\n                    value = obj[key];\n                    break;\n                }\n\n                if(!SIMPLE_PROPERTY_REGEX.test(key)) {\n                    value = lib.nestedProperty(obj, key).get();\n                    value = getterCache[key] || lib.nestedProperty(obj, key).get();\n                    if(value) getterCache[key] = value;\n                }\n                if(value !== undefined) break;\n            }\n        }\n\n        // Apply mult/div operation (if applicable)\n        if(value !== undefined) {\n            if(parsedOp === '*') value *= parsedNumber;\n            if(parsedOp === '/') value /= parsedNumber;\n        }\n\n        if(value === undefined && opts) {\n            if(opts.count < opts.max) {\n                lib.warn('Variable \\'' + key + '\\' in ' + opts.name + ' could not be found!');\n                value = match;\n            }\n\n            if(opts.count === opts.max) {\n                lib.warn('Too many ' + opts.name + ' warnings - additional warnings will be suppressed');\n            }\n            opts.count++;\n\n            return match;\n        }\n\n        if(format) {\n            var fmt;\n            if(format[0] === ':') {\n                fmt = d3locale ? d3locale.numberFormat : lib.numberFormat;\n                value = fmt(format.replace(TEMPLATE_STRING_FORMAT_SEPARATOR, ''))(value);\n            }\n\n            if(format[0] === '|') {\n                fmt = d3locale ? d3locale.timeFormat : utcFormat;\n                var ms = lib.dateTime2ms(value);\n                value = lib.formatDate(ms, format.replace(TEMPLATE_STRING_FORMAT_SEPARATOR, ''), false, fmt);\n            }\n        } else {\n            var keyLabel = key + 'Label';\n            if(labels.hasOwnProperty(keyLabel)) value = labels[keyLabel];\n        }\n\n        if(hasOther) {\n            value = '(' + value + ')';\n            if(isSpaceOther || isSpaceOtherSpace) value = ' ' + value;\n            if(isOtherSpace || isSpaceOtherSpace) value = value + ' ';\n        }\n\n        return value;\n    });\n}\n\n/*\n * alphanumeric string sort, tailored for subplot IDs like scene2, scene10, x10y13 etc\n */\nvar char0 = 48;\nvar char9 = 57;\nlib.subplotSort = function(a, b) {\n    var l = Math.min(a.length, b.length) + 1;\n    var numA = 0;\n    var numB = 0;\n    for(var i = 0; i < l; i++) {\n        var charA = a.charCodeAt(i) || 0;\n        var charB = b.charCodeAt(i) || 0;\n        var isNumA = charA >= char0 && charA <= char9;\n        var isNumB = charB >= char0 && charB <= char9;\n\n        if(isNumA) numA = 10 * numA + charA - char0;\n        if(isNumB) numB = 10 * numB + charB - char0;\n\n        if(!isNumA || !isNumB) {\n            if(numA !== numB) return numA - numB;\n            if(charA !== charB) return charA - charB;\n        }\n    }\n    return numB - numA;\n};\n\n// repeatable pseudorandom generator\nvar randSeed = 2000000000;\n\nlib.seedPseudoRandom = function() {\n    randSeed = 2000000000;\n};\n\nlib.pseudoRandom = function() {\n    var lastVal = randSeed;\n    randSeed = (69069 * randSeed + 1) % 4294967296;\n    // don't let consecutive vals be too close together\n    // gets away from really trying to be random, in favor of better local uniformity\n    if(Math.abs(randSeed - lastVal) < 429496729) return lib.pseudoRandom();\n    return randSeed / 4294967296;\n};\n\n\n/** Fill hover 'pointData' container with 'correct' hover text value\n *\n * - If trace hoverinfo contains a 'text' flag and hovertext is not set,\n *   the text elements will be seen in the hover labels.\n *\n * - If trace hoverinfo contains a 'text' flag and hovertext is set,\n *   hovertext takes precedence over text\n *   i.e. the hoverinfo elements will be seen in the hover labels\n *\n *  @param {object} calcPt\n *  @param {object} trace\n *  @param {object || array} contOut (mutated here)\n */\nlib.fillText = function(calcPt, trace, contOut) {\n    var fill = Array.isArray(contOut) ?\n        function(v) { contOut.push(v); } :\n        function(v) { contOut.text = v; };\n\n    var htx = lib.extractOption(calcPt, trace, 'htx', 'hovertext');\n    if(lib.isValidTextValue(htx)) return fill(htx);\n\n    var tx = lib.extractOption(calcPt, trace, 'tx', 'text');\n    if(lib.isValidTextValue(tx)) return fill(tx);\n};\n\n// accept all truthy values and 0 (which gets cast to '0' in the hover labels)\nlib.isValidTextValue = function(v) {\n    return v || v === 0;\n};\n\n/**\n * @param {number} ratio\n * @param {number} n (number of decimal places)\n */\nlib.formatPercent = function(ratio, n) {\n    n = n || 0;\n    var str = (Math.round(100 * ratio * Math.pow(10, n)) * Math.pow(0.1, n)).toFixed(n) + '%';\n    for(var i = 0; i < n; i++) {\n        if(str.indexOf('.') !== -1) {\n            str = str.replace('0%', '%');\n            str = str.replace('.%', '%');\n        }\n    }\n    return str;\n};\n\nlib.isHidden = function(gd) {\n    var display = window.getComputedStyle(gd).display;\n    return !display || display === 'none';\n};\n\nlib.strTranslate = function(x, y) {\n    return (x || y) ? 'translate(' + x + ',' + y + ')' : '';\n};\n\nlib.strRotate = function(a) {\n    return a ? 'rotate(' + a + ')' : '';\n};\n\nlib.strScale = function(s) {\n    return s !== 1 ? 'scale(' + s + ')' : '';\n};\n\n/** Return transform text for bar bar-like rectangles and pie-like slices\n *  @param {object} transform\n *  - targetX: desired position on the x-axis\n *  - targetY: desired position on the y-axis\n *  - textX: text middle position on the x-axis\n *  - textY: text middle position on the y-axis\n *  - anchorX: (optional) text anchor position on the x-axis (computed from textX), zero for middle anchor\n *  - anchorY: (optional) text anchor position on the y-axis (computed from textY), zero for middle anchor\n *  - scale: (optional) scale applied after translate\n *  - rotate: (optional) rotation applied after scale\n *  - noCenter: when defined no extra arguments needed in rotation\n */\nlib.getTextTransform = function(transform) {\n    var noCenter = transform.noCenter;\n    var textX = transform.textX;\n    var textY = transform.textY;\n    var targetX = transform.targetX;\n    var targetY = transform.targetY;\n    var anchorX = transform.anchorX || 0;\n    var anchorY = transform.anchorY || 0;\n    var rotate = transform.rotate;\n    var scale = transform.scale;\n    if(!scale) scale = 0;\n    else if(scale > 1) scale = 1;\n\n    return (\n        lib.strTranslate(\n            targetX - scale * (textX + anchorX),\n            targetY - scale * (textY + anchorY)\n        ) +\n        lib.strScale(scale) +\n        (rotate ?\n            'rotate(' + rotate +\n                (noCenter ? '' : ' ' + textX + ' ' + textY) +\n            ')' : ''\n        )\n    );\n};\n\nlib.setTransormAndDisplay = function(s, transform) {\n    s.attr('transform', lib.getTextTransform(transform));\n    s.style('display', transform.scale ? null : 'none');\n};\n\nlib.ensureUniformFontSize = function(gd, baseFont) {\n    var out = lib.extendFlat({}, baseFont);\n    out.size = Math.max(\n        baseFont.size,\n        gd._fullLayout.uniformtext.minsize || 0\n    );\n    return out;\n};\n\n/**\n * provide a human-readable list e.g. \"A, B, C and D\" with an ending separator\n *\n * @param {array} arr : the array to join\n * @param {string} mainSeparator : main separator\n * @param {string} lastSeparator : last separator\n *\n * @return {string} : joined list\n */\nlib.join2 = function(arr, mainSeparator, lastSeparator) {\n    var len = arr.length;\n    if(len > 1) {\n        return arr.slice(0, -1).join(mainSeparator) + lastSeparator + arr[len - 1];\n    }\n    return arr.join(mainSeparator);\n};\n\nlib.bigFont = function(size) {\n    return Math.round(1.2 * size);\n};\n\nvar firefoxVersion = lib.getFirefoxVersion();\n// see https://bugzilla.mozilla.org/show_bug.cgi?id=1684973\nvar isProblematicFirefox = firefoxVersion !== null && firefoxVersion < 86;\n\n/**\n * Return the mouse position from the last event registered by D3.\n * @returns An array with two numbers, representing the x and y coordinates of the mouse pointer\n *   at the event relative to the targeted node.\n */\nlib.getPositionFromD3Event = function() {\n    if(isProblematicFirefox) {\n        // layerX and layerY are non-standard, so we only fallback to them when we have to:\n        return [\n            d3.event.layerX,\n            d3.event.layerY\n        ];\n    } else {\n        return [\n            d3.event.offsetX,\n            d3.event.offsetY\n        ];\n    }\n};\n","'use strict';\n\n// more info: http://stackoverflow.com/questions/18531624/isplainobject-thing\nmodule.exports = function isPlainObject(obj) {\n    // We need to be a little less strict in the `imagetest` container because\n    // of how async image requests are handled.\n    //\n    // N.B. isPlainObject(new Constructor()) will return true in `imagetest`\n    if(window && window.process && window.process.versions) {\n        return Object.prototype.toString.call(obj) === '[object Object]';\n    }\n\n    return (\n        Object.prototype.toString.call(obj) === '[object Object]' &&\n        Object.getPrototypeOf(obj).hasOwnProperty('hasOwnProperty')\n    );\n};\n","'use strict';\n\nvar nestedProperty = require('./nested_property');\n\nvar SIMPLE_PROPERTY_REGEX = /^\\w*$/;\n\n// bitmask for deciding what's updated. Sometimes the name needs to be updated,\n// sometimes the value needs to be updated, and sometimes both do. This is just\n// a simple way to track what's updated such that it's a simple OR operation to\n// assimilate new updates.\n//\n// The only exception is the UNSET bit that tracks when we need to explicitly\n// unset and remove the property. This concrn arises because of the special\n// way in which nestedProperty handles null/undefined. When you specify `null`,\n// it prunes any unused items in the tree. I ran into some issues with it getting\n// null vs undefined confused, so UNSET is just a bit that forces the property\n// update to send `null`, removing the property explicitly rather than setting\n// it to undefined.\nvar NONE = 0;\nvar NAME = 1;\nvar VALUE = 2;\nvar BOTH = 3;\nvar UNSET = 4;\n\nmodule.exports = function keyedContainer(baseObj, path, keyName, valueName) {\n    keyName = keyName || 'name';\n    valueName = valueName || 'value';\n    var i, arr, baseProp;\n    var changeTypes = {};\n\n    if(path && path.length) {\n        baseProp = nestedProperty(baseObj, path);\n        arr = baseProp.get();\n    } else {\n        arr = baseObj;\n    }\n\n    path = path || '';\n\n    // Construct an index:\n    var indexLookup = {};\n    if(arr) {\n        for(i = 0; i < arr.length; i++) {\n            indexLookup[arr[i][keyName]] = i;\n        }\n    }\n\n    var isSimpleValueProp = SIMPLE_PROPERTY_REGEX.test(valueName);\n\n    var obj = {\n        set: function(name, value) {\n            var changeType = value === null ? UNSET : NONE;\n\n            // create the base array if necessary\n            if(!arr) {\n                if(!baseProp || changeType === UNSET) return;\n\n                arr = [];\n                baseProp.set(arr);\n            }\n\n            var idx = indexLookup[name];\n            if(idx === undefined) {\n                if(changeType === UNSET) return;\n\n                changeType = changeType | BOTH;\n                idx = arr.length;\n                indexLookup[name] = idx;\n            } else if(value !== (isSimpleValueProp ? arr[idx][valueName] : nestedProperty(arr[idx], valueName).get())) {\n                changeType = changeType | VALUE;\n            }\n\n            var newValue = arr[idx] = arr[idx] || {};\n            newValue[keyName] = name;\n\n            if(isSimpleValueProp) {\n                newValue[valueName] = value;\n            } else {\n                nestedProperty(newValue, valueName).set(value);\n            }\n\n            // If it's not an unset, force that bit to be unset. This is all related to the fact\n            // that undefined and null are a bit specially implemented in nestedProperties.\n            if(value !== null) {\n                changeType = changeType & ~UNSET;\n            }\n\n            changeTypes[idx] = changeTypes[idx] | changeType;\n\n            return obj;\n        },\n        get: function(name) {\n            if(!arr) return;\n\n            var idx = indexLookup[name];\n\n            if(idx === undefined) {\n                return undefined;\n            } else if(isSimpleValueProp) {\n                return arr[idx][valueName];\n            } else {\n                return nestedProperty(arr[idx], valueName).get();\n            }\n        },\n        rename: function(name, newName) {\n            var idx = indexLookup[name];\n\n            if(idx === undefined) return obj;\n            changeTypes[idx] = changeTypes[idx] | NAME;\n\n            indexLookup[newName] = idx;\n            delete indexLookup[name];\n\n            arr[idx][keyName] = newName;\n\n            return obj;\n        },\n        remove: function(name) {\n            var idx = indexLookup[name];\n\n            if(idx === undefined) return obj;\n\n            var object = arr[idx];\n            if(Object.keys(object).length > 2) {\n                // This object contains more than just the key/value, so unset\n                // the value without modifying the entry otherwise:\n                changeTypes[idx] = changeTypes[idx] | VALUE;\n                return obj.set(name, null);\n            }\n\n            if(isSimpleValueProp) {\n                for(i = idx; i < arr.length; i++) {\n                    changeTypes[i] = changeTypes[i] | BOTH;\n                }\n                for(i = idx; i < arr.length; i++) {\n                    indexLookup[arr[i][keyName]]--;\n                }\n                arr.splice(idx, 1);\n                delete(indexLookup[name]);\n            } else {\n                // Perform this update *strictly* so we can check whether the result's\n                // been pruned. If so, it's a removal. If not, it's a value unset only.\n                nestedProperty(object, valueName).set(null);\n\n                // Now check if the top level nested property has any keys left. If so,\n                // the object still has values so we only want to unset the key. If not,\n                // the entire object can be removed since there's no other data.\n                // var topLevelKeys = Object.keys(object[valueName.split('.')[0]] || []);\n\n                changeTypes[idx] = changeTypes[idx] | VALUE | UNSET;\n            }\n\n            return obj;\n        },\n        constructUpdate: function() {\n            var astr, idx;\n            var update = {};\n            var changed = Object.keys(changeTypes);\n            for(var i = 0; i < changed.length; i++) {\n                idx = changed[i];\n                astr = path + '[' + idx + ']';\n                if(arr[idx]) {\n                    if(changeTypes[idx] & NAME) {\n                        update[astr + '.' + keyName] = arr[idx][keyName];\n                    }\n                    if(changeTypes[idx] & VALUE) {\n                        if(isSimpleValueProp) {\n                            update[astr + '.' + valueName] = (changeTypes[idx] & UNSET) ? null : arr[idx][valueName];\n                        } else {\n                            update[astr + '.' + valueName] = (changeTypes[idx] & UNSET) ? null : nestedProperty(arr[idx], valueName).get();\n                        }\n                    }\n                } else {\n                    update[astr] = null;\n                }\n            }\n\n            return update;\n        }\n    };\n\n    return obj;\n};\n","'use strict';\n\nvar Registry = require('../registry');\n\n/**\n * localize: translate a string for the current locale\n *\n * @param {object} gd: the graphDiv for context\n *  gd._context.locale determines the language (& optional region/country)\n *  the dictionary for each locale may either be supplied in\n *  gd._context.locales or globally via Plotly.register\n * @param {string} s: the string to translate\n */\nmodule.exports = function localize(gd, s) {\n    var locale = gd._context.locale;\n\n    /*\n     * Priority of lookup:\n     *     contextDicts[locale],\n     *     registeredDicts[locale],\n     *     contextDicts[baseLocale], (if baseLocale is distinct)\n     *     registeredDicts[baseLocale]\n     * Return the first translation we find.\n     * This way if you have a regionalization you are allowed to specify\n     * only what's different from the base locale, everything else will\n     * fall back on the base.\n     */\n    for(var i = 0; i < 2; i++) {\n        var locales = gd._context.locales;\n        for(var j = 0; j < 2; j++) {\n            var dict = (locales[locale] || {}).dictionary;\n            if(dict) {\n                var out = dict[s];\n                if(out) return out;\n            }\n            locales = Registry.localeRegistry;\n        }\n\n        var baseLocale = locale.split('-')[0];\n        if(baseLocale === locale) break;\n        locale = baseLocale;\n    }\n\n    return s;\n};\n","'use strict';\n\n/* eslint-disable no-console */\n\nvar dfltConfig = require('../plot_api/plot_config').dfltConfig;\n\nvar notifier = require('./notifier');\n\nvar loggers = module.exports = {};\n\n/**\n * ------------------------------------------\n * debugging tools\n * ------------------------------------------\n */\n\nloggers.log = function() {\n    var i;\n\n    if(dfltConfig.logging > 1) {\n        var messages = ['LOG:'];\n        for(i = 0; i < arguments.length; i++) {\n            messages.push(arguments[i]);\n        }\n        console.trace.apply(console, messages);\n    }\n\n    if(dfltConfig.notifyOnLogging > 1) {\n        var lines = [];\n        for(i = 0; i < arguments.length; i++) {\n            lines.push(arguments[i]);\n        }\n        notifier(lines.join('<br>'), 'long');\n    }\n};\n\nloggers.warn = function() {\n    var i;\n\n    if(dfltConfig.logging > 0) {\n        var messages = ['WARN:'];\n        for(i = 0; i < arguments.length; i++) {\n            messages.push(arguments[i]);\n        }\n        console.trace.apply(console, messages);\n    }\n\n    if(dfltConfig.notifyOnLogging > 0) {\n        var lines = [];\n        for(i = 0; i < arguments.length; i++) {\n            lines.push(arguments[i]);\n        }\n        notifier(lines.join('<br>'), 'stick');\n    }\n};\n\nloggers.error = function() {\n    var i;\n\n    if(dfltConfig.logging > 0) {\n        var messages = ['ERROR:'];\n        for(i = 0; i < arguments.length; i++) {\n            messages.push(arguments[i]);\n        }\n        console.error.apply(console, messages);\n    }\n\n    if(dfltConfig.notifyOnLogging > 0) {\n        var lines = [];\n        for(i = 0; i < arguments.length; i++) {\n            lines.push(arguments[i]);\n        }\n        notifier(lines.join('<br>'), 'stick');\n    }\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\n\n/**\n * General helper to manage trace groups based on calcdata\n *\n * @param {d3.selection} traceLayer: a selection containing a single group\n *     to draw these traces into\n * @param {array} cdModule: array of calcdata items for this\n *     module and subplot combination. Assumes the calcdata item for each\n *     trace is an array with the fullData trace attached to the first item.\n * @param {string} cls: the class attribute to give each trace group\n *     so you can give multiple classes separated by spaces\n */\nmodule.exports = function makeTraceGroups(traceLayer, cdModule, cls) {\n    var traces = traceLayer.selectAll('g.' + cls.replace(/\\s/g, '.'))\n        .data(cdModule, function(cd) { return cd[0].trace.uid; });\n\n    traces.exit().remove();\n\n    traces.enter().append('g')\n        .attr('class', cls);\n\n    traces.order();\n\n    // stash ref node to trace group in calcdata,\n    // useful for (fast) styleOnSelect\n    var k = traceLayer.classed('rangeplot') ? 'nodeRangePlot3' : 'node3';\n    traces.each(function(cd) { cd[0][k] = d3.select(this); });\n\n    return traces;\n};\n","'use strict';\n\nvar mat4X4 = require('gl-mat4');\n\nexports.init2dArray = function(rowLength, colLength) {\n    var array = new Array(rowLength);\n    for(var i = 0; i < rowLength; i++) array[i] = new Array(colLength);\n    return array;\n};\n\n/**\n * transpose a (possibly ragged) 2d array z. inspired by\n * http://stackoverflow.com/questions/17428587/\n * transposing-a-2d-array-in-javascript\n */\nexports.transposeRagged = function(z) {\n    var maxlen = 0;\n    var zlen = z.length;\n    var i, j;\n    // Maximum row length:\n    for(i = 0; i < zlen; i++) maxlen = Math.max(maxlen, z[i].length);\n\n    var t = new Array(maxlen);\n    for(i = 0; i < maxlen; i++) {\n        t[i] = new Array(zlen);\n        for(j = 0; j < zlen; j++) t[i][j] = z[j][i];\n    }\n\n    return t;\n};\n\n// our own dot function so that we don't need to include numeric\nexports.dot = function(x, y) {\n    if(!(x.length && y.length) || x.length !== y.length) return null;\n\n    var len = x.length;\n    var out;\n    var i;\n\n    if(x[0].length) {\n        // mat-vec or mat-mat\n        out = new Array(len);\n        for(i = 0; i < len; i++) out[i] = exports.dot(x[i], y);\n    } else if(y[0].length) {\n        // vec-mat\n        var yTranspose = exports.transposeRagged(y);\n        out = new Array(yTranspose.length);\n        for(i = 0; i < yTranspose.length; i++) out[i] = exports.dot(x, yTranspose[i]);\n    } else {\n        // vec-vec\n        out = 0;\n        for(i = 0; i < len; i++) out += x[i] * y[i];\n    }\n\n    return out;\n};\n\n// translate by (x,y)\nexports.translationMatrix = function(x, y) {\n    return [[1, 0, x], [0, 1, y], [0, 0, 1]];\n};\n\n// rotate by alpha around (0,0)\nexports.rotationMatrix = function(alpha) {\n    var a = alpha * Math.PI / 180;\n    return [[Math.cos(a), -Math.sin(a), 0],\n            [Math.sin(a), Math.cos(a), 0],\n            [0, 0, 1]];\n};\n\n// rotate by alpha around (x,y)\nexports.rotationXYMatrix = function(a, x, y) {\n    return exports.dot(\n        exports.dot(exports.translationMatrix(x, y),\n                    exports.rotationMatrix(a)),\n        exports.translationMatrix(-x, -y));\n};\n\n// applies a 3D transformation matrix to either x, y and z params\n// Note: z is optional\nexports.apply3DTransform = function(transform) {\n    return function() {\n        var args = arguments;\n        var xyz = arguments.length === 1 ? args[0] : [args[0], args[1], args[2] || 0];\n        return exports.dot(transform, [xyz[0], xyz[1], xyz[2], 1]).slice(0, 3);\n    };\n};\n\n// applies a 2D transformation matrix to either x and y params or an [x,y] array\nexports.apply2DTransform = function(transform) {\n    return function() {\n        var args = arguments;\n        if(args.length === 3) {\n            args = args[0];\n        } // from map\n        var xy = arguments.length === 1 ? args[0] : [args[0], args[1]];\n        return exports.dot(transform, [xy[0], xy[1], 1]).slice(0, 2);\n    };\n};\n\n// applies a 2D transformation matrix to an [x1,y1,x2,y2] array (to transform a segment)\nexports.apply2DTransform2 = function(transform) {\n    var at = exports.apply2DTransform(transform);\n    return function(xys) {\n        return at(xys.slice(0, 2)).concat(at(xys.slice(2, 4)));\n    };\n};\n\nexports.convertCssMatrix = function(m) {\n    if(m) {\n        var len = m.length;\n        if(len === 16) return m;\n        if(len === 6) {\n            // converts a 2x3 css transform matrix to a 4x4 matrix see https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix\n            return [\n                m[0], m[1], 0, 0,\n                m[2], m[3], 0, 0,\n                0, 0, 1, 0,\n                m[4], m[5], 0, 1\n            ];\n        }\n    }\n    return [\n        1, 0, 0, 0,\n        0, 1, 0, 0,\n        0, 0, 1, 0,\n        0, 0, 0, 1\n    ];\n};\n\n// find the inverse for a 4x4 affine transform matrix\nexports.inverseTransformMatrix = function(m) {\n    var out = [];\n    mat4X4.invert(out, m);\n    return [\n        [out[0], out[1], out[2], out[3]],\n        [out[4], out[5], out[6], out[7]],\n        [out[8], out[9], out[10], out[11]],\n        [out[12], out[13], out[14], out[15]]\n    ];\n};\n","'use strict';\n\n/**\n * sanitized modulus function that always returns in the range [0, d)\n * rather than (-d, 0] if v is negative\n */\nfunction mod(v, d) {\n    var out = v % d;\n    return out < 0 ? out + d : out;\n}\n\n/**\n * sanitized modulus function that always returns in the range [-d/2, d/2]\n * rather than (-d, 0] if v is negative\n */\nfunction modHalf(v, d) {\n    return Math.abs(v) > (d / 2) ?\n        v - Math.round(v / d) * d :\n        v;\n}\n\nmodule.exports = {\n    mod: mod,\n    modHalf: modHalf\n};\n"],"names":["exports","version","require","Registry","register","plotApi","methodNames","Object","keys","i","length","name","charAt","moduleType","fn","window","PlotlyLocales","Array","isArray","Icons","Fx","Plots","resize","graphJson","sendDataToCloud","hover","unhover","loneHover","loneUnhover","Snapshot","PlotSchema","module","undo","width","height","path","transform","home","zoombox","pan","zoom_plus","zoom_minus","autoscale","tooltip_basic","tooltip_compare","plotlylogo","camera","movie","question","disk","drawopenpath","drawclosedpath","lasso","selectbox","drawline","drawrect","drawcircle","eraseshape","spikeline","pencil","newplotlylogo","svg","join","isLeftAnchor","opts","xanchor","x","isCenterAnchor","isRightAnchor","isTopAnchor","yanchor","y","isMiddleAnchor","isBottomAnchor","modModule","mod","modHalf","PI","Math","twoPI","isFullCircle","aBnds","abs","angleDelta","a","b","isAngleInsideSector","s0","s1","a0","a1","_path","r0","r1","cx","cy","isClosed","aStart","aMid","aEnd","rStart","rEnd","isCircle","pt","r","cos","sin","p","largeArc","arc","cw","deg2rad","deg","rad2deg","rad","angleDist","isPtInsideSector","rBnds","pathArc","pathSector","pathAnnulus","b64decode","isPlainObject","ab","ArrayBuffer","dv","DataView","isTypedArray","isView","isArrayOrTypedArray","isArray1D","ensureArray","out","n","typedArrays","u1c","Uint8ClampedArray","undefined","i1","Int8Array","u1","Uint8Array","i2","Int16Array","u2","Uint16Array","i4","Int32Array","u4","Uint32Array","f4","Float32Array","f8","Float64Array","isArrayBuffer","constructor","_rowLength","z","len0","len","uint8c","uint8","int8","uint16","int16","uint32","int32","float32","float64","decodeTypedArraySpec","vIn","v","bdata","dtype","shape","coerceTypedArraySpec","T","Error","BYTES_PER_ELEMENT","buffer","byteLength","split","reverse","nj","j","ndim","ni","rowBytes","pos","nk","k","_inputArray","isTypedArraySpec","hasOwnProperty","concat","_constructor","arg0","argi","posi","leni","args","allArray","totalLen","arguments","push","apply","set","maxRowLength","max","minRowLength","min","Infinity","isNumeric","BADNUM","JUNK","replace","Number","gd","fullLayout","_fullLayout","_glcanvas","size","each","d","regl","clear","color","depth","_responsiveChartHandler","removeEventListener","tinycolor","baseTraceAttrs","colorscales","Color","DESELECTDIM","nestedProperty","counterRegex","validate","value","valObjectDef","valObjectMeta","valType","arrayOk","validateFunction","failed","propMock","coerceFunction","data_array","description","requiredOpts","otherOpts","propOut","dflt","enumerated","coerceNumber","values","indexOf","String","RegExp","substr","test","boolean","number","integer","string","okToCoerce","strict","noBlank","isValid","colorlist","every","colorscale","scales","get","angle","subplotid","regex","flaglist","extras","vParts","vi","flags","splice","any","info_array","coercePart","propPart","row","item","len2","vNew","twoD","dimensions","items","vOut","arrayItems","arrayItems2D","innerItemsOnly","freeLength","coerce","containerIn","containerOut","attributes","attribute","propIn","template","_template","coerce2","valIn","coerceFont","attr","dfltObj","family","coercePattern","markerColor","hasMarkerColorscale","isOverlay","bgcolor","contrast","coerceHoverinfo","traceIn","traceOut","layoutOut","moduleAttrs","_module","attrs","hoverinfo","valObj","_dataLength","slice","coerceSelectionMarkerOpacity","marker","smoDflt","usmoDflt","mo","opacity","selected","unselected","MIN_MS","MAX_MS","timeFormat","Loggers","constants","ONEDAY","ONEHOUR","ONEMIN","ONESEC","EPOCHJD","utcFormat","DATETIME_REGEXP","DATETIME_REGEXP_CN","YFIRST","Date","getFullYear","isWorldCalendar","calendar","componentsRegistry","calendars","lpad","val","digits","pow","dateTick0","dayOfWeek","tick0","sunday","getComponentMethod","_dateTick0","dateTime2ms","ms2DateTime","dfltRange","isJSDate","getTime","s","tzOffset","getTimezoneOffset","offsetTweak","getUTCMinutes","getMinutes","getUTCSeconds","getSeconds","getUTCMilliseconds","getMilliseconds","comb","isWorld","isChinese","match","m","H","M","S","cDate","calInstance","isIntercalary","parseInt","newDate","toMonthIndex","e","toJD","date","UTC","setUTCFullYear","getUTCMonth","getUTCDate","isDateTime","NINETYDAYS","THREEHOURS","FIVEMIN","includeTime","dateStr","h","msec10","ms","msecTenths","floor","msRounded","round","dateJD","timeMs","fromJD","formatDate","getUTCHours","ms2DateTimeLocal","getHours","cleanDate","isFinite","error","fracMatch","halfYearMatch","quarterToHalfYear","modDateFormat","fmt","formatter","toFixed","MAXSECONDS","tr","extraFormat","year","month","timePart","timeStr","secStr","formatTime","dayMonthYear","dayMonth","THREEDAYS","incrementMonth","dMonth","add","setUTCMonth","findExactDates","data","di","exactYears","exactMonths","exactDays","blankCount","day","dataCount","d3","loggers","matrix","mat4X4","removeElement","el","elParent","parentNode","removeChild","addRelatedStyleRule","uid","selector","styleString","id","style","document","getElementById","createElement","setAttribute","appendChild","createTextNode","head","styleSheet","sheet","insertRule","addRule","warn","getElementTransformMatrix","element","getComputedStyle","getPropertyValue","map","getElementAndAncestors","allElements","isTransformableElement","Element","HTMLElement","getGraphDiv","gdElement","isPlotDiv","el3","select","node","classed","addStyleRule","deleteRelatedStyleRule","getFullTransformMatrix","forEach","t","convertCssMatrix","multiply","equalDomRects","top","left","right","bottom","EventEmitter","Events","init","plotObj","_ev","ev","internalEv","_internalEv","on","bind","once","removeListener","removeAllListeners","_internalOn","_internalOnce","_removeInternalListener","_removeAllInternalListeners","emit","event","jQuery","trigger","triggerHandler","jQueryHandlerValue","nodeEventHandlerValue","handlers","_events","handler","listener","fired","purge","_extend","inputs","isDeep","keepAllKeys","noArrayCopies","input","key","src","copy","copyIsArray","clone","allPrimitives","target","source","primitivesLoopSplice","extendFlat","extendDeep","extendDeepAll","extendDeepNoArrays","array","seen","baseFilter","visible","calcDataFilter","trace","_length","container","cont","filterFn","locationCache","workingPath","workingTextWidth","segmentsIntersect","x1","y1","x2","y2","x3","y3","x4","y4","c","f","det","u","perpDistance2","xab","yab","llab","xac","yac","fcAB","xbc","ybc","crossProduct","segmentDistance","x12","y12","x34","y34","ll12","ll34","dist2","sqrt","getTextLocation","totalPathLen","positionOnPath","textWidth","p0","getPointAtLength","p1","theta","atan","pCenter","clearLocationCache","getVisibleSegment","bounds","pt0","ptTotal","pMin","pTotal","getTotalLength","pMax","getDistToPlot","dx","dy","distToPlot","total","findPointOnPath","coord","mid","diff","pathLength","tolerance","iterationLimit","mul","b0","b1","delta","scale","newX","lenX1","lenDt","parseFloat","toPrecision","d3Format","numConstants","MAX_SAFE","FP_SAFE","MIN_SAFE","lib","adjustFormat","formatStr","seenBadFormats","warnBadFormat","noFormat","numberFormat","keyedContainer","relativeAttr","toLogRange","relinkPrivateKeys","arrayModule","coerceModule","datesModule","searchModule","findBin","sorterAsc","sorterDes","distinctVals","roundUp","sort","findIndexOfMin","sortObjectKeys","statsModule","aggNums","mean","median","midRange","variance","stdev","interp","matrixModule","init2dArray","transposeRagged","dot","translationMatrix","rotationMatrix","rotationXYMatrix","apply3DTransform","apply2DTransform","apply2DTransform2","inverseTransformMatrix","anglesModule","anchorUtils","geom2dModule","extendModule","loggersModule","log","regexModule","counter","throttleModule","throttle","throttleDone","done","clearThrottle","domModule","makePtIndex2PtNumber","indexToPoints","ptIndex2ptNumber","pts","clearResponsive","preserveDrawingBuffer","makeTraceGroups","_","notifier","filterUnique","filterVisible","pushUnique","increment","cleanNumber","ensureNumber","isIndex","noop","identity","repeat","cnt","swapAttrs","attrList","part1","part2","xp","yp","temp","raiseToTop","elem","cancelTransition","selection","transition","duration","constrain","v0","v1","bBoxIntersect","pad","simpleMap","func","randstr","existing","bits","base","_recursion","res","rem","random","toString","parsed","OptionControl","opt","optname","self","optObj","optionList","smooth","arrayIn","FWHM","alen","alen2","wlen","w","arrayOut","syncOrAsync","sequence","arg","finalStep","ret","continueAsync","fni","then","stripTrailingSlash","str","noneOrAll","hasAny","hasAll","mergeArray","traceAttr","cd","cdAttr","hasFn","imax","mergeArrayCastPositive","fillArray","castOption","ptNumber","astr","extractOption","calcPt","calcKey","traceKey","traceVal","tagSelected","calcTrace","ptNumber2cdIndex","selectedpoints","_indexToPoints","ptIndex","cdIndex","selIndices2selPoints","getTargetArray","transformOpts","minExtend","obj1","obj2","objOut","arrayLen","subarray","titleCase","toUpperCase","containsAny","fragments","isIE","navigator","msSaveBlob","IS_SAFARI_REGEX","isSafari","userAgent","IS_IOS_REGEX","isIOS","FIREFOX_VERSION_REGEX","getFirefoxVersion","exec","versionInt","isNaN","isD3Selection","obj","ensureSingle","parent","nodeType","className","enterFn","sel","layer","append","call","ensureSingleById","objectFromPath","tmpObj","parts","dottedPropertyRegex","indexedPropertyRegex","notValid","prop","expandObjectPaths","datum","idx","dest","trailingPath","numSeparate","separators","separatethousands","thousandsRe","decimalSep","thouSep","TEMPLATE_STRING_REGEX","SIMPLE_PROPERTY_REGEX","templateString","getterCache","dummy","isValidTextValue","hovertemplateWarnings","count","hovertemplateString","templateFormatString","texttemplateWarnings","texttemplateString","MULT_DIV_REGEX","texttemplateWarningsForShapes","parseMultDiv","texttemplateStringForShapes","TEMPLATE_STRING_FORMAT_SEPARATOR","labels","d3locale","this","rawKey","format","isSpaceOther","isSpaceOtherSpace","isOtherSpace","hasOther","substring","parsedOp","parsedNumber","_match","inputStr","op","multDivParser","keyLabel","subplotSort","l","numA","numB","charA","charCodeAt","charB","isNumA","isNumB","randSeed","seedPseudoRandom","pseudoRandom","lastVal","fillText","contOut","fill","text","htx","tx","formatPercent","ratio","isHidden","display","strTranslate","strRotate","strScale","getTextTransform","noCenter","textX","textY","targetX","targetY","anchorX","anchorY","rotate","setTransormAndDisplay","ensureUniformFontSize","baseFont","uniformtext","minsize","join2","arr","mainSeparator","lastSeparator","bigFont","firefoxVersion","isProblematicFirefox","getPositionFromD3Event","layerX","layerY","offsetX","offsetY","process","versions","prototype","getPrototypeOf","baseObj","keyName","valueName","baseProp","changeTypes","indexLookup","isSimpleValueProp","changeType","newValue","rename","newName","remove","object","constructUpdate","update","changed","locale","_context","locales","dict","dictionary","localeRegistry","baseLocale","dfltConfig","logging","messages","console","notifyOnLogging","lines","traceLayer","cdModule","cls","traces","selectAll","exit","enter","order","rowLength","colLength","maxlen","zlen","yTranspose","alpha","xyz","xy","at","xys","invert"],"sourceRoot":""}