@d3plus/core 3.0.0-alpha.0

package/es/src/charts/Plot.js

@@ -0,0 +1,2212 @@
+/* eslint no-cond-assign: 0 */ function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { deviation, extent, max, mean, merge, min, range, sum } from "d3-array";
+import { nest } from "d3-collection";
+import * as scales from "d3-scale";
+import * as d3Shape from "d3-shape";
+import { colorAssign, colorContrast, colorDefaults, colorLegible } from "@d3plus/color";
+import { merge as d3plusMerge, unique } from "@d3plus/data";
+import { assign, date, elem, rtl, textWidth } from "@d3plus/dom";
+import { largestRect } from "@d3plus/math";
+import { formatAbbreviate } from "@d3plus/format";
+import { AxisBottom, AxisLeft, AxisRight, AxisTop, TextBox } from "../components/index.js";
+import * as shapes from "../shapes/index.js";
+import { accessor, configPrep, constant } from "../utils/index.js";
+var testLineShape = new shapes.Line();
+var testTextBox = new TextBox();
+import Viz from "./Viz.js";
+import { default as discreteBuffer } from "./plotBuffers/discreteBuffer.js";
+import { default as BarBuffer } from "./plotBuffers/Bar.js";
+import { default as BoxBuffer } from "./plotBuffers/Box.js";
+import { default as CircleBuffer } from "./plotBuffers/Circle.js";
+import { default as LineBuffer } from "./plotBuffers/Line.js";
+import { default as RectBuffer } from "./plotBuffers/Rect.js";
+var defaultBuffers = {
+    Bar: BarBuffer,
+    Box: BoxBuffer,
+    Circle: CircleBuffer,
+    Line: LineBuffer,
+    Rect: RectBuffer
+};
+/**
+    @desc Logic for determining default sizes of shapes using the sizeScaleD3 internal function.
+    @private
+*/ function defaultSize(d) {
+    return this._sizeScaleD3(this._size ? this._size(d) : null);
+}
+/**
+    @desc Logic for determining stackOrder ascending using groups.
+    @private
+*/ function stackOrderAscending(series) {
+    var sums = series.map(stackSum);
+    var keys = series.map(function(d) {
+        return d.key.split("_")[0];
+    });
+    return d3Shape.stackOrderNone(series).sort(function(a, b) {
+        return keys[b].localeCompare(keys[a]) || sums[a] - sums[b];
+    });
+}
+/**
+    @desc Logic for determining stackOrder descending using groups.
+    @private
+*/ function stackOrderDescending(series) {
+    return stackOrderAscending(series).reverse();
+}
+/**
+    @desc Logic for determining default sum of shapes using the stackSum function used in d3Shape.
+    @private
+*/ function stackSum(series) {
+    var i = -1, s = 0, v;
+    var n = series.length;
+    while(++i < n)if (v = +series[i][1]) s += v;
+    return s;
+}
+/**
+    @desc Logic for determining default sum of shapes using the stackSum function used in d3Shape.
+    @private
+*/ function stackOffsetDiverging(series, order) {
+    var n;
+    if (!((n = series.length) > 0)) return;
+    var d, dy, i, yn, yp;
+    var m = series[order[0]].length;
+    for(var j = 0; j < m; ++j){
+        for(yp = yn = 0, i = 0; i < n; ++i){
+            if ((dy = (d = series[order[i]][j])[1] - d[0]) >= 0) {
+                d[0] = yp, d[1] = yp += dy;
+            } else if (dy < 0) {
+                d[1] = yn, d[0] = yn += dy;
+            } else {
+                d[0] = yp;
+            }
+        }
+    }
+}
+/**
+ * Determines if a Bar label should be placed outside of the Bar.
+ * @param {@} d
+ * @param {*} i
+ * @private
+ */ function outside(d, i) {
+    // Force all Stacked Bars to use "inside" labels.
+    if (this._stacked) return false;
+    // Detect user "outside" or "inside" override.
+    var labelPosition = this._labelPosition(d, i);
+    if (labelPosition === "outside") return true;
+    else if (labelPosition === "inside") return false;
+    // Run "auto" logic based on available space.
+    var other = this._discrete.charAt(0) === "x" ? "y" : "x";
+    var nonDiscrete = this._discrete.replace(this._discrete.charAt(0), other);
+    var range = this["_".concat(nonDiscrete, "Axis")]._d3Scale.range();
+    var value = this["_".concat(nonDiscrete)](d, i);
+    var negative = value < 0;
+    var zero = this["_".concat(nonDiscrete, "Axis")]._getPosition(0);
+    var space = nonDiscrete === "y" ? negative ? range[1] - zero : zero - range[0] : negative ? zero - range[0] : range[1] - zero;
+    var pos = this["_".concat(nonDiscrete, "Axis")]._getPosition(value);
+    var size = Math.abs(negative ? zero - pos : pos - zero);
+    return size < space / 2;
+}
+var Plot = /*#__PURE__*/ function(Viz) {
+    "use strict";
+    _inherits(Plot, Viz);
+    function Plot() {
+        _class_call_check(this, Plot);
+        var _this;
+        _this = _call_super(this, Plot);
+        _this._axisPersist = false;
+        _this._annotations = [];
+        _this._backgroundConfig = {
+            duration: 0,
+            fill: "transparent"
+        };
+        _this._barPadding = 0;
+        _this._buffer = assign({}, defaultBuffers, {
+            Bar: false,
+            Line: false
+        });
+        _this._confidenceConfig = {
+            fill: function(d, i) {
+                var c = typeof _this._shapeConfig.Line.stroke === "function" ? _this._shapeConfig.Line.stroke(d, i) : _this._shapeConfig.Line.stroke;
+                return c;
+            },
+            fillOpacity: constant(0.5)
+        };
+        _this._discreteCutoff = 100;
+        _this._groupPadding = 5;
+        _this._labelConnectorConfig = {
+            strokeDasharray: "1 1"
+        };
+        _this._labelPosition = constant("auto");
+        _this._lineMarkerConfig = {
+            fill: function(d, i) {
+                return colorAssign(_this._id(d, i));
+            },
+            r: constant(3)
+        };
+        _this._lineMarkers = false;
+        _this._previousAnnotations = {
+            back: [],
+            front: []
+        };
+        _this._previousShapes = [];
+        _this._shape = constant("Circle");
+        _this._shapeConfig = assign(_this._shapeConfig, {
+            Area: {
+                label: function(d, i) {
+                    return _this._stacked ? _this._drawLabel(d, i) : false;
+                },
+                labelBounds: function(d, i, aes) {
+                    var r = largestRect(aes.points, {
+                        angle: range(-20, 20, 5)
+                    });
+                    if (!r || r.height < 20 || r.width < 50) r = largestRect(aes.points, {
+                        angle: range(-80, 80, 5)
+                    });
+                    if (!r) return null;
+                    var x = min(aes.points, function(d) {
+                        return d[0];
+                    });
+                    var y = max(aes.points.filter(function(d) {
+                        return d[0] === x;
+                    }), function(d) {
+                        return d[1];
+                    });
+                    return {
+                        angle: r.angle,
+                        width: r.width,
+                        height: r.height,
+                        x: r.cx - r.width / 2 - x,
+                        y: r.cy - r.height / 2 - y
+                    };
+                },
+                labelConfig: {
+                    fontMin: 6,
+                    fontResize: true,
+                    padding: 10
+                }
+            },
+            ariaLabel: function(d, i) {
+                var ariaLabelStr = "";
+                if (d.nested) ariaLabelStr = "".concat(_this._drawLabel(d.data, d.i));
+                else {
+                    ariaLabelStr = "".concat(_this._drawLabel(d, i));
+                    if (_this._x(d, i) !== undefined) ariaLabelStr += ", x: ".concat(_this._x(d, i));
+                    if (_this._y(d, i) !== undefined) ariaLabelStr += ", y: ".concat(_this._y(d, i));
+                    if (_this._x2(d, i) !== undefined) ariaLabelStr += ", x2: ".concat(_this._x2(d, i));
+                    if (_this._y2(d, i) !== undefined) ariaLabelStr += ", y2: ".concat(_this._y2(d, i));
+                }
+                return "".concat(ariaLabelStr, ".");
+            },
+            Bar: {
+                labelBounds: function labelBounds(d, i, s) {
+                    var padding = 1;
+                    var width = this._discrete === "y" ? "width" : "height";
+                    var height = this._discrete === "y" ? "height" : "width";
+                    var other = this._discrete.charAt(0) === "x" ? "y" : "x";
+                    var invert = other === "y";
+                    var nonDiscrete = this._discrete.replace(this._discrete.charAt(0), other);
+                    var range = this["_".concat(nonDiscrete, "Axis")]._d3Scale.range();
+                    var space = Math.abs(range[1] - range[0]);
+                    var negative = this["_".concat(nonDiscrete)](d, i) < 0;
+                    if (outside.bind(this)(d, i)) {
+                        var _obj;
+                        return _obj = {}, _define_property(_obj, width, space - s[width]), _define_property(_obj, height, s[height]), _define_property(_obj, "x", invert ? -s.width / 2 : negative ? -space : s.width + padding), _define_property(_obj, "y", invert ? negative ? s.height + padding : -space : -s.height / 2 + 1), _obj;
+                    }
+                    var _obj1;
+                    return _obj1 = {}, _define_property(_obj1, width, s[width]), _define_property(_obj1, height, s[height]), _define_property(_obj1, "x", invert ? -s.width / 2 : negative ? this._stacked ? padding - s.width : padding - s.width : -padding), _define_property(_obj1, "y", invert ? negative ? this._stacked ? padding : padding : -s.height + padding : -s.height / 2 + padding), _obj1;
+                },
+                labelConfig: {
+                    fontMax: 16,
+                    fontMin: 6,
+                    fontResize: true,
+                    fontColor: function fontColor(d, i) {
+                        return outside.bind(this)(d, i) ? this._backgroundConfig.fill === "transparent" ? colorDefaults.dark : colorContrast(this._backgroundConfig.fill) : colorContrast(typeof this._shapeConfig.fill === "function" ? this._shapeConfig.fill(d, i) : this._shapeConfig.fill);
+                    },
+                    fontStroke: function fontStroke(d, i) {
+                        return outside.bind(this)(d, i) ? this._backgroundConfig.fill === "transparent" ? colorDefaults.dark : colorContrast(this._backgroundConfig.fill) : "transparent";
+                    },
+                    fontStrokeWidth: function fontStrokeWidth(d, i) {
+                        return outside.bind(this)(d, i) ? 0.1 : 0;
+                    },
+                    padding: 3,
+                    textAnchor: function textAnchor(d, i) {
+                        var other = this._discrete.charAt(0) === "x" ? "y" : "x";
+                        var invert = other === "y";
+                        var nonDiscrete = this._discrete.replace(this._discrete.charAt(0), other);
+                        var negative = this["_".concat(nonDiscrete)](d, i) < 0;
+                        var anchor = invert ? "middle" : outside.bind(this)(d, i) ? negative ? "end" : "start" : negative ? "start" : "end";
+                        return rtl() ? anchor === "start" ? "end" : anchor === "end" ? "start" : anchor : anchor;
+                    },
+                    verticalAlign: function verticalAlign(d, i) {
+                        var other = this._discrete.charAt(0) === "x" ? "y" : "x";
+                        var invert = other === "y";
+                        var nonDiscrete = this._discrete.replace(this._discrete.charAt(0), other);
+                        var negative = this["_".concat(nonDiscrete)](d, i) < 0;
+                        return invert ? outside.bind(this)(d, i) ? negative ? "top" : "bottom" : negative ? "bottom" : "top" : "middle";
+                    }
+                }
+            },
+            Circle: {
+                r: defaultSize.bind(_this)
+            },
+            Line: {
+                curve: function() {
+                    return _this._discrete ? "monotone".concat(_this._discrete.charAt(0).toUpperCase()) : "linear";
+                },
+                fill: constant("none"),
+                labelConfig: {
+                    fontColor: function(d, i) {
+                        var c = typeof _this._shapeConfig.Line.stroke === "function" ? _this._shapeConfig.Line.stroke(d, i) : _this._shapeConfig.Line.stroke;
+                        return colorLegible(c);
+                    },
+                    fontResize: false,
+                    padding: 5,
+                    textAnchor: "start",
+                    verticalAlign: "middle"
+                },
+                strokeWidth: constant(2)
+            },
+            Rect: {
+                height: function(d) {
+                    return defaultSize.bind(_this)(d) * 2;
+                },
+                width: function(d) {
+                    return defaultSize.bind(_this)(d) * 2;
+                }
+            }
+        });
+        _this._shapeOrder = [
+            "Area",
+            "Path",
+            "Bar",
+            "Box",
+            "Line",
+            "Rect",
+            "Circle"
+        ];
+        _this._shapeSort = function(a, b) {
+            return _this._shapeOrder.indexOf(a) - _this._shapeOrder.indexOf(b);
+        };
+        _this._sizeMax = 20;
+        _this._sizeMin = 5;
+        _this._sizeScale = "sqrt";
+        _this._stackOffset = stackOffsetDiverging;
+        _this._stackOrder = stackOrderDescending;
+        _this._timelineConfig = assign(_this._timelineConfig, {
+            brushing: true,
+            brushMin: function() {
+                return _this._xTime || _this._yTime || _this._x2Time || _this._y2Time ? 2 : 1;
+            }
+        });
+        _this._x = accessor("x");
+        _this._xAxis = new AxisBottom().align("end");
+        _this._xTest = new AxisBottom().align("end").gridSize(0);
+        _this._xConfig = {
+            gridConfig: {
+                stroke: function(d) {
+                    if (_this._discrete && _this._discrete.charAt(0) === "x") return "transparent";
+                    var range = _this._xAxis.range();
+                    // hides left-most x gridline so it doesn't overlap with the y axis
+                    return range[0] === _this._xAxis._getPosition.bind(_this._xAxis)(d.id) ? "transparent" : "#eee";
+                }
+            }
+        };
+        _this._xCutoff = 150;
+        _this._x2 = accessor("x2");
+        _this._x2Axis = new AxisTop().align("start");
+        _this._x2Test = new AxisTop().align("start").gridSize(0);
+        _this._x2Config = {
+            padding: 0
+        };
+        _this._y = accessor("y");
+        _this._yAxis = new AxisLeft().align("start");
+        _this._yTest = new AxisLeft().align("start").gridSize(0);
+        _this._yConfig = {
+            gridConfig: {
+                stroke: function(d) {
+                    if (_this._discrete && _this._discrete.charAt(0) === "y") return "transparent";
+                    var range = _this._yAxis.range();
+                    // hides bottom-most y gridline so it doesn't overlap with the x axis
+                    return range[range.length - 1] === _this._yAxis._getPosition.bind(_this._yAxis)(d.id) ? "transparent" : "#eee";
+                }
+            }
+        };
+        _this._yCutoff = 150;
+        _this._y2 = accessor("y2");
+        _this._y2Axis = new AxisRight().align("end");
+        _this._y2Test = new AxisLeft().align("end").gridSize(0);
+        _this._y2Config = {};
+        return _this;
+    }
+    _create_class(Plot, [
+        {
+            /**
+      Extends the preDraw behavior of the abstract Viz class.
+      @private
+  */ key: "_preDraw",
+            value: function _preDraw() {
+                var _this = this;
+                // logic repeated for each axis
+                [
+                    "x",
+                    "y",
+                    "x2",
+                    "y2"
+                ].forEach(function(k) {
+                    // if user has supplied a String key as the main method value
+                    if (_this["_".concat(k, "Key")]) {
+                        var str = _this["_".concat(k, "Key")];
+                        // if axis is discrete and numerical, do not sum values
+                        if (!_this._aggs[str] && _this._discrete === k) {
+                            _this._aggs[str] = function(a, c) {
+                                var v = Array.from(new Set(a.map(c)));
+                                return v.length === 1 ? v[0] : v;
+                            };
+                        }
+                        // set axis title if not discrete
+                        if (str !== k && _this["_".concat(k, "Title")] === _this["_".concat(k, "Config")].title && _this._discrete !== k) {
+                            _this["_".concat(k, "Title")] = str;
+                            _this["_".concat(k, "Config")].title = str;
+                        }
+                    }
+                });
+                _get(_get_prototype_of(Plot.prototype), "_preDraw", this).call(this);
+            }
+        },
+        {
+            /**
+      Extends the draw behavior of the abstract Viz class.
+      @private
+  */ key: "_draw",
+            value: function _draw(callback) {
+                var _this = this;
+                if (!this._filteredData.length) return this;
+                /* Determines whether or not any of the x or y axes are a "time" axis. */ var firstElemTime = this._time ? this._time(this._filteredData[0], 0) : false;
+                var x2Time = this._x2Time = firstElemTime && this._x2(this._filteredData[0], 0) === firstElemTime, xTime = this._xTime = firstElemTime && this._x(this._filteredData[0], 0) === firstElemTime, y2Time = this._y2Time = firstElemTime && this._y2(this._filteredData[0], 0) === firstElemTime, yTime = this._yTime = firstElemTime && this._y(this._filteredData[0], 0) === firstElemTime;
+                var timeAxis = xTime || x2Time || yTime || y2Time;
+                var stackGroup = function(d, i) {
+                    return "".concat(!timeAxis && _this._time ? _this._time(d, i) : "time", "_").concat(_this._stacked ? "".concat(_this._groupBy.length > 1 ? _this._ids(d, i).slice(0, -1).join("_") : "group") : "".concat(_this._ids(d, i).join("_")));
+                };
+                var prepData = function(d, i) {
+                    var newD = {
+                        __d3plus__: true,
+                        data: d,
+                        group: stackGroup(d, i),
+                        i: i,
+                        hci: _this._confidence && _this._confidence[1] && _this._confidence[1](d, i),
+                        id: _this._ids(d, i).slice(0, _this._drawDepth + 1).join("_"),
+                        lci: _this._confidence && _this._confidence[0] && _this._confidence[0](d, i),
+                        shape: _this._shape(d, i),
+                        x: xTime ? date(_this._x(d, i)) : _this._x(d, i),
+                        x2: x2Time ? date(_this._x2(d, i)) : _this._x2(d, i),
+                        y: yTime ? date(_this._y(d, i)) : _this._y(d, i),
+                        y2: y2Time ? date(_this._y2(d, i)) : _this._y2(d, i)
+                    };
+                    newD.discrete = newD.shape === "Bar" ? "".concat(newD[_this._discrete], "_").concat(newD.group) : "".concat(newD[_this._discrete]);
+                    newD.id = newD.shape === "Bar" ? "".concat(newD.id, "_").concat(newD[_this._discrete]) : newD.id;
+                    return newD;
+                };
+                var data = this._formattedData = this._filteredData.map(prepData);
+                var axisData = this._axisPersist ? this._data.map(prepData) : data;
+                if (this._size) {
+                    var rExtent = extent(axisData, function(d) {
+                        return _this._size(d.data);
+                    });
+                    this._sizeScaleD3 = scales["scale".concat(this._sizeScale.charAt(0).toUpperCase()).concat(this._sizeScale.slice(1))]().domain(rExtent).range([
+                        rExtent[0] === rExtent[1] ? this._sizeMax : min([
+                            this._sizeMax / 2,
+                            this._sizeMin
+                        ]),
+                        this._sizeMax
+                    ]);
+                } else {
+                    this._sizeScaleD3 = function() {
+                        return _this._sizeMin;
+                    };
+                }
+                var x2Exists = axisData.some(function(d) {
+                    return d.x2 !== undefined;
+                }), y2Exists = axisData.some(function(d) {
+                    return d.y2 !== undefined;
+                });
+                var height = this._height - this._margin.top - this._margin.bottom, opp = this._discrete ? this._discrete === "x" ? "y" : "x" : undefined, opp2 = this._discrete ? this._discrete === "x" ? "y2" : "x2" : undefined, opps = [
+                    opp,
+                    opp2
+                ].filter(function(d) {
+                    return d;
+                }), parent = this._select, transition = this._transition, width = this._width - this._margin.left - this._margin.right;
+                /**
+     * @desc Returns all unique values for a given axis.
+     * @param {String} axis
+     * @returns {Array}
+     * @private
+     */ function getAxisValues(axis) {
+                    var _this = this;
+                    var timeData = this["_".concat(axis, "Time")];
+                    var localData = timeData ? data : axisData;
+                    var filteredData = localData.filter(function(d) {
+                        return ![
+                            NaN,
+                            undefined,
+                            false
+                        ].includes(d[axis]);
+                    });
+                    if (!filteredData.length) return [];
+                    var numericValue = typeof filteredData[0][axis] === "number";
+                    var myData = this._discrete === axis ? nest().key(function(d) {
+                        return d[axis];
+                    }).rollup(function(leaves) {
+                        return leaves.length === 1 ? leaves[0].data : d3plusMerge(leaves.map(function(d) {
+                            return d.data;
+                        }), _this._aggs);
+                    }).entries(filteredData).sort(function(a, b) {
+                        if (_this["_".concat(axis, "Sort")]) return _this["_".concat(axis, "Sort")](a.value, b.value);
+                        var aKey = timeData || numericValue ? parseFloat(a.key, 10) : a.key;
+                        var bKey = timeData || numericValue ? parseFloat(b.key, 10) : b.key;
+                        return aKey - bKey;
+                    }).map(function(d) {
+                        return timeData ? date(d.key) : numericValue ? parseFloat(d.key, 10) : d.key;
+                    }) : unique(filteredData.sort(function(a, b) {
+                        return _this["_".concat(axis, "Sort")] ? _this["_".concat(axis, "Sort")](a.data, b.data) : a[axis] - b[axis];
+                    }).map(function(d) {
+                        return d[axis];
+                    }), function(d) {
+                        return "".concat(d);
+                    });
+                    if (this._discrete !== axis.charAt(0) && this._confidence) {
+                        if (this._confidence[0]) myData = myData.concat(localData.map(function(d) {
+                            return d.lci;
+                        }));
+                        if (this._confidence[1]) myData = myData.concat(localData.map(function(d) {
+                            return d.hci;
+                        }));
+                    }
+                    return myData;
+                }
+                var xData = getAxisValues.bind(this)("x");
+                var x2Data = getAxisValues.bind(this)("x2");
+                var yData = getAxisValues.bind(this)("y");
+                var y2Data = getAxisValues.bind(this)("y2");
+                var discreteKeys, domains, stackData, stackKeys;
+                if (this._stacked) {
+                    var stackedData = axisData.filter(function(d) {
+                        return [
+                            "Area",
+                            "Bar"
+                        ].includes(d.shape);
+                    });
+                    var groupValues = nest().key(function(d) {
+                        return d.group;
+                    }).entries(stackedData).reduce(function(obj, d) {
+                        if (!obj[d.key]) obj[d.key] = 0;
+                        obj[d.key] += sum(d.values, function(dd) {
+                            return dd[opp];
+                        });
+                        return obj;
+                    }, {});
+                    axisData.sort(function(a, b) {
+                        if (_this["_".concat(_this._discrete, "Sort")]) return _this["_".concat(_this._discrete, "Sort")](a.data, b.data);
+                        var a1 = a[_this._discrete], b1 = b[_this._discrete];
+                        if (a1 - b1 !== 0) return a1 - b1;
+                        if (a.group !== b.group) return groupValues[b.group] - groupValues[a.group];
+                        return b[opp] - a[opp];
+                    });
+                    discreteKeys = Array.from(new Set(axisData.map(function(d) {
+                        return d.discrete;
+                    })));
+                    stackKeys = Array.from(new Set(axisData.map(function(d) {
+                        return d.id;
+                    })));
+                    stackData = nest().key(function(d) {
+                        return d.discrete;
+                    }).entries(axisData).map(function(d) {
+                        return d.values;
+                    });
+                    stackData.forEach(function(g) {
+                        var ids = Array.from(new Set(g.map(function(d) {
+                            return d.id;
+                        })));
+                        if (ids.length < stackKeys.length) {
+                            stackKeys.forEach(function(k) {
+                                if (!ids.includes(k)) {
+                                    var d = axisData.filter(function(d) {
+                                        return d.id === k;
+                                    })[0];
+                                    if (d.shape === "Area") {
+                                        var group = stackGroup(d.data, d.i);
+                                        var _obj;
+                                        var fillerPoint = (_obj = {
+                                            __d3plus__: true,
+                                            data: d.data,
+                                            discrete: d.shape === "Bar" ? "".concat(g[0][_this._discrete], "_").concat(group) : "".concat(g[0][_this._discrete]),
+                                            group: group,
+                                            id: d.id,
+                                            ids: k,
+                                            shape: d.shape
+                                        }, _define_property(_obj, _this._discrete, g[0][_this._discrete]), _define_property(_obj, opp, 0), _obj);
+                                        data.push(fillerPoint);
+                                    }
+                                }
+                            });
+                        }
+                    });
+                    if (this["_".concat(this._discrete, "Sort")]) {
+                        data.sort(function(a, b) {
+                            return _this["_".concat(_this._discrete, "Sort")](a.data, b.data);
+                        });
+                    } else {
+                        data.sort(function(a, b) {
+                            return a[_this._discrete] - b[_this._discrete];
+                        });
+                    }
+                    var order = this._stackOrder;
+                    if (_instanceof(order, Array)) stackKeys.sort(function(a, b) {
+                        return order.indexOf(a) - order.indexOf(b);
+                    });
+                    else if (order === d3Shape.stackOrderNone) stackKeys.sort(function(a, b) {
+                        return a.localeCompare(b);
+                    });
+                    stackData = d3Shape.stack().keys(stackKeys).offset(this._stackOffset).order(_instanceof(order, Array) ? d3Shape.stackOrderNone : order).value(function(group, key) {
+                        var d = group.filter(function(g) {
+                            return g.id === key;
+                        });
+                        return d.length ? d[0][opp] : 0;
+                    })(stackData);
+                    var discreteData = this._discrete === "x" ? xData : yData;
+                    var _obj;
+                    domains = (_obj = {}, _define_property(_obj, this._discrete, this["_".concat(this._discrete, "Time")] ? extent(discreteData) : discreteData), _define_property(_obj, opp, [
+                        min(stackData.map(function(g) {
+                            return min(g.map(function(p) {
+                                return p[0];
+                            }));
+                        })),
+                        max(stackData.map(function(g) {
+                            return max(g.map(function(p) {
+                                return p[1];
+                            }));
+                        }))
+                    ]), _obj);
+                } else {
+                    var discrete = this._discrete || "x";
+                    if (this["_".concat(this._discrete, "Sort")]) {
+                        axisData.sort(function(a, b) {
+                            return _this["_".concat(_this._discrete, "Sort")](a.data, b.data);
+                        });
+                    } else {
+                        axisData.sort(function(a, b) {
+                            return a[discrete] - b[discrete];
+                        });
+                    }
+                    domains = {
+                        x: !xTime && this._discrete === "x" || this._xSort ? xData : extent(xData),
+                        x2: !x2Time && this._discrete === "x" || this._x2Sort ? x2Data : extent(x2Data),
+                        y: !yTime && this._discrete === "y" || this._ySort ? yData : extent(yData),
+                        y2: !y2Time && this._discrete === "y" || this._y2Sort ? y2Data : extent(y2Data)
+                    };
+                }
+                /**
+     * Determins default scale type and domain for a given axis.
+     * @param {String} axis
+     * @private
+     */ function domainScaleSetup(axis) {
+                    var scale = this["_".concat(axis, "Time")] ? "Time" : this._discrete === axis || this["_".concat(axis, "Sort")] ? "Point" : "Linear";
+                    var domain = this["_".concat(axis, "Domain")] ? this["_".concat(axis, "Domain")].slice() : domains[axis], domain2 = this["_".concat(axis, "2Domain")] ? this["_".concat(axis, "2Domain")].slice() : domains["".concat(axis, "2")];
+                    if (scale !== "Point") {
+                        if (domain && domain[0] === void 0) domain[0] = domains[axis][0];
+                        if (domain && domain[1] === void 0) domain[1] = domains[axis][1];
+                        if (domain2 && domain2[0] === void 0) domain2[0] = domains["".concat(axis, "2")][0];
+                        if (domain2 && domain2[1] === void 0) domain2[1] = domains["".concat(axis, "2")][1];
+                    }
+                    return [
+                        domain,
+                        scale,
+                        domain2,
+                        scale
+                    ];
+                }
+                var _domainScaleSetup_bind = _sliced_to_array(domainScaleSetup.bind(this)("x"), 4), xAutoDomain = _domainScaleSetup_bind[0], xScale = _domainScaleSetup_bind[1], x2AutoDomain = _domainScaleSetup_bind[2], x2Scale = _domainScaleSetup_bind[3];
+                var _domainScaleSetup_bind1 = _sliced_to_array(domainScaleSetup.bind(this)("y"), 4), yAutoDomain = _domainScaleSetup_bind1[0], yScale = _domainScaleSetup_bind1[1], y2AutoDomain = _domainScaleSetup_bind1[2], y2Scale = _domainScaleSetup_bind1[3];
+                var autoScale = function(axis, fallback) {
+                    var userScale = _this["_".concat(axis, "Config")].scale;
+                    if (userScale === "auto") {
+                        if (_this._discrete === axis) return fallback;
+                        var values = axisData.map(function(d) {
+                            return d[axis];
+                        });
+                        return deviation(values) / mean(values) > 3 ? "log" : "linear";
+                    }
+                    return userScale || fallback;
+                };
+                var yConfigScale = this._yConfigScale = autoScale("y", yScale).toLowerCase();
+                var y2ConfigScale = this._y2ConfigScale = autoScale("y2", y2Scale).toLowerCase();
+                var xConfigScale = this._xConfigScale = autoScale("x", xScale).toLowerCase();
+                var x2ConfigScale = this._x2ConfigScale = autoScale("x2", x2Scale).toLowerCase();
+                domains = {
+                    x: xAutoDomain,
+                    x2: x2AutoDomain || xAutoDomain,
+                    y: yAutoDomain,
+                    y2: y2AutoDomain || yAutoDomain
+                };
+                Object.keys(domains).forEach(function(axis) {
+                    if (_this["_".concat(axis, "ConfigScale")] === "log" && domains[axis].includes(0)) {
+                        if (min(domains[axis]) < 0) domains[axis][1] = max(data.map(function(d) {
+                            return d[axis];
+                        }).filter(function(d) {
+                            return ![
+                                NaN,
+                                undefined,
+                                false
+                            ].includes(d);
+                        }));
+                        else domains[axis][0] = min(axisData.map(function(d) {
+                            return d[axis];
+                        }).filter(function(d) {
+                            return ![
+                                NaN,
+                                undefined,
+                                false
+                            ].includes(d);
+                        }));
+                    }
+                });
+                opps.forEach(function(opp) {
+                    if (_this["_".concat(opp, "Config")].domain) {
+                        var d = _this["_".concat(opp, "Config")].domain;
+                        if (_this._discrete === "x") d.reverse();
+                        domains[opp] = d;
+                    } else if (opp && _this._baseline !== void 0) {
+                        var b = _this._baseline;
+                        if (domains[opp] && domains[opp][0] > b) domains[opp][0] = b;
+                        else if (domains[opp] && domains[opp][1] < b) domains[opp][1] = b;
+                    }
+                });
+                var x = scales["scale".concat(xScale)]().domain(domains.x).range(range(0, width + 1, width / (domains.x.length - 1))), x2 = scales["scale".concat(x2Scale)]().domain(domains.x2).range(range(0, width + 1, width / (domains.x2.length - 1))), y = scales["scale".concat(yScale)]().domain(domains.y.reverse()).range(range(0, height + 1, height / (domains.y.length - 1))), y2 = scales["scale".concat(y2Scale)]().domain(domains.y2.reverse()).range(range(0, height + 1, height / (domains.y2.length - 1)));
+                var shapeData = nest().key(function(d) {
+                    return d.shape;
+                }).entries(data).sort(function(a, b) {
+                    return _this._shapeSort(a.key, b.key);
+                });
+                var oppScale = this._discrete === "x" ? yScale : xScale;
+                if (oppScale !== "Point") {
+                    var allShapeData = nest().key(function(d) {
+                        return d.shape;
+                    }).entries(axisData);
+                    allShapeData.forEach(function(d) {
+                        if ([
+                            "Bar",
+                            "Box"
+                        ].includes(d.key)) {
+                            discreteBuffer(_this._discrete === "x" ? x : y, data, _this._discrete);
+                        }
+                        if (_this._buffer[d.key]) {
+                            var res = _this._buffer[d.key].bind(_this)({
+                                data: d.values,
+                                x: x,
+                                y: y,
+                                yScale: yConfigScale,
+                                xScale: xConfigScale,
+                                config: _this._shapeConfig[d.key]
+                            });
+                            x = res[0];
+                            y = res[1];
+                            var res2 = _this._buffer[d.key].bind(_this)({
+                                data: d.values,
+                                x: x2,
+                                y: y2,
+                                yScale: y2ConfigScale,
+                                xScale: x2ConfigScale,
+                                x2: true,
+                                y2: true,
+                                config: _this._shapeConfig[d.key]
+                            });
+                            x2 = res2[0];
+                            y2 = res2[1];
+                        }
+                    });
+                }
+                var xDomain = x.domain();
+                var x2Domain = x2.domain();
+                var yDomain = y.domain();
+                var y2Domain = y2.domain();
+                var defaultConfig = {
+                    barConfig: {
+                        "stroke-width": 0
+                    },
+                    gridSize: 0,
+                    labels: [],
+                    title: false,
+                    tickSize: 0
+                };
+                var defaultX2Config = x2Exists ? {
+                    data: x2Data
+                } : defaultConfig;
+                var defaultY2Config = y2Exists ? {
+                    data: y2Data
+                } : defaultConfig;
+                var showX = this._discrete === "x" && this._width > this._discreteCutoff || this._width > this._xCutoff;
+                var showY = this._discrete === "y" && this._height > this._discreteCutoff || this._height > this._yCutoff;
+                var yC = {
+                    data: yData,
+                    locale: this._locale,
+                    rounding: this._yDomain ? "none" : "outside",
+                    scalePadding: y.padding ? y.padding() : 0
+                };
+                if (!showX) {
+                    yC.barConfig = {
+                        stroke: "transparent"
+                    };
+                    yC.tickSize = 0;
+                    yC.shapeConfig = {
+                        labelBounds: function(d, i) {
+                            var _d_labelBounds = d.labelBounds, width = _d_labelBounds.width, y = _d_labelBounds.y;
+                            var height = _this._height / 2;
+                            var x = i ? -height : 0;
+                            return {
+                                x: x,
+                                y: y,
+                                width: width,
+                                height: height
+                            };
+                        },
+                        labelConfig: {
+                            padding: 0,
+                            rotate: 0
+                        },
+                        labelRotation: false
+                    };
+                }
+                var testGroup = elem("g.d3plus-plot-test", {
+                    enter: {
+                        opacity: 0
+                    },
+                    parent: this._select
+                });
+                /**
+     * Hides an axis' ticks and labels if they all exist as labels for the data to be displayed,
+     * primarily occuring in simple BarChart visualizations where the both the x-axis ticks and
+     * the Bar rectangles would be displaying the same text.
+     */ // generates an Array of String labels using the current label function for Bar shapes
+                var barConfig = configPrep.bind(this)(this._shapeConfig, "shape", "Bar");
+                var barLabelFunction = barConfig.label !== undefined ? typeof barConfig.label === "function" ? barConfig.label : constant(barConfig.label) : this._drawLabel;
+                var barLabels = axisData.map(function(d) {
+                    return barLabelFunction(d.data, d.i);
+                }).filter(function(d) {
+                    return typeof d === "number" || d;
+                }).map(String);
+                // sets an axis' ticks to [] if the axis scale is "Point" (discrete) and every tick String
+                // is also in the barLabels Array
+                var x2Ticks = unique(axisData.map(function(d) {
+                    return d.x2;
+                }));
+                x2Ticks = x2Scale === "Point" && x2Ticks.every(function(t) {
+                    return barLabels.includes("".concat(t));
+                }) ? [] : null;
+                var xTicks = unique(axisData.map(function(d) {
+                    return d.x;
+                }));
+                xTicks = xScale === "Point" && xTicks.every(function(t) {
+                    return barLabels.includes("".concat(t));
+                }) ? [] : null;
+                var y2Ticks = unique(axisData.map(function(d) {
+                    return d.y2;
+                }));
+                y2Ticks = y2Scale === "Point" && y2Ticks.every(function(t) {
+                    return barLabels.includes("".concat(t));
+                }) ? [] : null;
+                var yTicks = unique(axisData.map(function(d) {
+                    return d.y;
+                }));
+                yTicks = yScale === "Point" && yTicks.every(function(t) {
+                    return barLabels.includes("".concat(t));
+                }) ? [] : null;
+                if (showY) {
+                    this._yTest.domain(yDomain).height(height).maxSize(width / 2).range([
+                        undefined,
+                        undefined
+                    ]).select(testGroup.node()).ticks(yTicks).width(width).config(yC).config(this._yConfig).scale(yConfigScale).render();
+                }
+                var yBounds = this._yTest.outerBounds();
+                var yWidth = yBounds.width ? yBounds.width + this._yTest.padding() : undefined;
+                if (y2Exists) {
+                    this._y2Test.domain(y2Domain).height(height).range([
+                        undefined,
+                        undefined
+                    ]).select(testGroup.node()).ticks(y2Ticks).width(width).config(yC).config(defaultY2Config).config(this._y2Config).scale(y2ConfigScale).render();
+                }
+                var y2Bounds = this._y2Test.outerBounds();
+                var y2Width = y2Bounds.width ? y2Bounds.width + this._y2Test.padding() : undefined;
+                var xC = {
+                    data: xData,
+                    locale: this._locale,
+                    rounding: this._xDomain ? "none" : "outside",
+                    scalePadding: x.padding ? x.padding() : 0
+                };
+                if (!showY) {
+                    xC.barConfig = {
+                        stroke: "transparent"
+                    };
+                    xC.tickSize = 0;
+                    xC.shapeConfig = {
+                        labelBounds: function(d, i) {
+                            var _d_labelBounds = d.labelBounds, height = _d_labelBounds.height, y = _d_labelBounds.y;
+                            var width = _this._width / 2;
+                            var x = i ? -width : 0;
+                            return {
+                                x: x,
+                                y: y,
+                                width: width,
+                                height: height
+                            };
+                        },
+                        labelConfig: {
+                            padding: 0,
+                            rotate: 0,
+                            textAnchor: function(d) {
+                                return d.id === xTicks[0] ? "start" : "end";
+                            }
+                        },
+                        labelRotation: false
+                    };
+                }
+                var xRangeMax = undefined;
+                if (showX) {
+                    this._xTest.domain(xDomain).height(height).maxSize(height / 2).range([
+                        undefined,
+                        xRangeMax
+                    ]).select(testGroup.node()).ticks(xTicks).width(width).config(xC).config(this._xConfig).scale(xConfigScale).render();
+                }
+                var largestLabel, labelWidths = [];
+                var showLineLabels = this._lineLabels && !y2Exists;
+                if (showLineLabels) {
+                    var labelData = data.filter(function(d) {
+                        if (d.shape !== "Line") return false;
+                        return typeof _this._lineLabels === "function" ? _this._lineLabels(d.data, d.i) : true;
+                    });
+                    var lineData = nest().key(function(d) {
+                        return d.id;
+                    }).entries(labelData);
+                    if (lineData.length) {
+                        var userConfig = configPrep.bind(this)(this._shapeConfig, "shape", "Line");
+                        testLineShape.config(userConfig);
+                        var lineLabelConfig = testLineShape.labelConfig();
+                        var fontColorAccessor = lineLabelConfig.fontColor !== undefined ? lineLabelConfig.fontColor : testTextBox.fontColor();
+                        var fontSizeAccessor = lineLabelConfig.fontSize !== undefined ? lineLabelConfig.fontSize : testTextBox.fontSize();
+                        var fontWeightAccessor = lineLabelConfig.fontWeight !== undefined ? lineLabelConfig.fontWeight : testTextBox.fontWeight();
+                        var fontFamilyAccessor = lineLabelConfig.fontFamily !== undefined ? lineLabelConfig.fontFamily : testTextBox.fontFamily();
+                        var paddingAccessor = lineLabelConfig.padding !== undefined ? lineLabelConfig.padding : testTextBox.padding();
+                        var labelFunction = userConfig.label || this._drawLabel;
+                        var xEstimate = function(d) {
+                            if (xConfigScale === "log" && d === 0) d = xDomain[0] < 0 ? _this._xTest._d3Scale.domain()[1] : _this._xTest._d3Scale.domain()[0];
+                            return _this._xTest._getPosition.bind(_this._xTest)(d);
+                        };
+                        var yEstimate = function(d) {
+                            if (yConfigScale === "log" && d === 0) d = yDomain[0] < 0 ? _this._yTest._d3Scale.domain()[1] : _this._yTest._d3Scale.domain()[0];
+                            return _this._yTest._getPosition.bind(_this._yTest)(d);
+                        };
+                        labelWidths = lineData.map(function(group) {
+                            var d = group.values[group.values.length - 1];
+                            var i;
+                            while(d.__d3plus__ && d.data){
+                                d = d.data;
+                                i = d.i;
+                            }
+                            var label = typeof labelFunction === "function" ? labelFunction(d, i) : labelFunction;
+                            var fontColor = typeof fontColorAccessor === "function" ? fontColorAccessor(d, i) : fontColorAccessor;
+                            var fontSize = typeof fontSizeAccessor === "function" ? fontSizeAccessor(d, i) : fontSizeAccessor;
+                            var fontWeight = typeof fontWeightAccessor === "function" ? fontWeightAccessor(d, i) : fontWeightAccessor;
+                            var fontFamily = typeof fontFamilyAccessor === "function" ? fontFamilyAccessor(d, i) : fontFamilyAccessor;
+                            if (_instanceof(fontFamily, Array)) fontFamily = fontFamily.map(function(f) {
+                                return "'".concat(f, "'");
+                            }).join(", ");
+                            var labelPadding = typeof paddingAccessor === "function" ? paddingAccessor(d, i) : paddingAccessor;
+                            var labelWidth = textWidth(label, {
+                                "font-size": fontSize,
+                                "font-family": fontFamily,
+                                "font-weight": fontWeight
+                            });
+                            var coords = group.values.map(function(d) {
+                                return [
+                                    xEstimate(d.x),
+                                    yEstimate(d.y)
+                                ];
+                            });
+                            var myMaxX = max(group.values.map(function(d) {
+                                return xEstimate(d.x);
+                            }));
+                            var labelY = group.values.find(function(d) {
+                                return xEstimate(d.x) === myMaxX;
+                            }).y;
+                            return {
+                                id: group.key,
+                                labelWidth: labelWidth + labelPadding * 2,
+                                spaceNeeded: labelWidth + labelPadding * 4,
+                                value: labelY,
+                                yEstimate: yEstimate(labelY),
+                                padding: labelPadding,
+                                fontSize: fontSize,
+                                fontColor: fontColor,
+                                maxX: myMaxX,
+                                xValue: max(group.values, function(d) {
+                                    return d.x;
+                                }),
+                                coords: coords
+                            };
+                        }).sort(function(a, b) {
+                            return yDomain[1] > yDomain[0] ? a.value - b.value : b.value - a.value;
+                        }).filter(function(d, i, arr) {
+                            var fontSize = d.fontSize, id = d.id, labelWidth = d.labelWidth, maxX = d.maxX, yEstimate = d.yEstimate;
+                            var closeLabels = arr.filter(function(l) {
+                                return l.id !== id && l.coords.some(function(c) {
+                                    return (c[0] > maxX || c[0] === maxX && l.maxX !== maxX) && c[0] <= maxX + labelWidth && c[1] <= yEstimate + fontSize * 0.75 && c[1] >= yEstimate - fontSize * 0.75;
+                                });
+                            });
+                            return closeLabels.length === 0;
+                        });
+                        var maxX = max(labelWidths, function(d) {
+                            return d.maxX;
+                        });
+                        largestLabel = max(labelWidths.map(function(d) {
+                            return d.labelWidth;
+                        }));
+                        var spaceNeeded = maxX === this._xTest._getRange.bind(this._xTest)()[1] ? max(labelWidths.filter(function(d) {
+                            return d.maxX === maxX;
+                        }), function(d) {
+                            return d.spaceNeeded;
+                        }) : 0;
+                        if (spaceNeeded) {
+                            var labelSpace = min([
+                                spaceNeeded,
+                                width / 4
+                            ]);
+                            xRangeMax = width - labelSpace - this._margin.right;
+                        }
+                    }
+                }
+                if (showX && xRangeMax) {
+                    this._xTest.domain(xDomain).height(height).maxSize(height / 2).range([
+                        undefined,
+                        xRangeMax
+                    ]).select(testGroup.node()).ticks(xTicks).width(width).config(xC).config(this._xConfig).scale(xConfigScale).render();
+                }
+                if (x2Exists) {
+                    this._x2Test.domain(x2Domain).height(height).range([
+                        undefined,
+                        xRangeMax
+                    ]).select(testGroup.node()).ticks(x2Ticks).width(width).config(xC).tickSize(0).config(defaultX2Config).config(this._x2Config).scale(x2ConfigScale).render();
+                }
+                var xTestRange = this._xTest._getRange();
+                var x2TestRange = this._x2Test._getRange();
+                var x2Bounds = this._x2Test.outerBounds();
+                var x2Height = x2Exists ? x2Bounds.height + this._x2Test.padding() : 0;
+                var xOffsetLeft = max([
+                    yWidth,
+                    xTestRange[0],
+                    x2TestRange[0]
+                ]);
+                if (showX) {
+                    this._xTest.range([
+                        xOffsetLeft,
+                        undefined
+                    ]).render();
+                }
+                var topOffset = showY ? this._yTest.shapeConfig().labelConfig.fontSize() / 2 : 0;
+                var xOffsetRight = max([
+                    y2Width,
+                    width - xTestRange[1],
+                    width - x2TestRange[1]
+                ]);
+                var xBounds = this._xTest.outerBounds();
+                var xHeight = xBounds.height + (showY ? this._xTest.padding() : 0);
+                this._padding.left += xOffsetLeft;
+                this._padding.right += xOffsetRight;
+                this._padding.bottom += xHeight;
+                this._padding.top += x2Height + topOffset;
+                _get(_get_prototype_of(Plot.prototype), "_draw", this).call(this, callback);
+                var horizontalMargin = this._margin.left + this._margin.right;
+                var verticalMargin = this._margin.top + this._margin.bottom;
+                var yRange = [
+                    x2Height,
+                    height - (xHeight + topOffset + verticalMargin)
+                ];
+                if (showY) {
+                    this._yTest.domain(yDomain).height(height).maxSize(width / 2).range(yRange).select(testGroup.node()).ticks(yTicks).width(width).config(yC).config(this._yConfig).scale(yConfigScale).render();
+                }
+                yBounds = this._yTest.outerBounds();
+                yWidth = yBounds.width ? yBounds.width + this._yTest.padding() : undefined;
+                xOffsetLeft = max([
+                    yWidth,
+                    xTestRange[0],
+                    x2TestRange[0]
+                ]);
+                if (y2Exists) {
+                    this._y2Test.config(yC).domain(y2Domain).gridSize(0).height(height).range(yRange).select(testGroup.node()).width(width - max([
+                        0,
+                        xOffsetRight - y2Width
+                    ])).title(false).config(this._y2Config).config(defaultY2Config).scale(y2ConfigScale).render();
+                }
+                y2Bounds = this._y2Test.outerBounds();
+                y2Width = y2Bounds.width ? y2Bounds.width + this._y2Test.padding() : undefined;
+                xOffsetRight = max([
+                    0,
+                    y2Width,
+                    width - xTestRange[1],
+                    width - x2TestRange[1]
+                ]);
+                var xRange = [
+                    xOffsetLeft,
+                    width - (xOffsetRight + horizontalMargin)
+                ];
+                var rectGroup = elem("g.d3plus-plot-background", {
+                    parent: parent,
+                    transition: transition
+                });
+                var transform = "translate(".concat(this._margin.left, ", ").concat(this._margin.top + x2Height + topOffset, ")");
+                var x2Transform = "translate(".concat(this._margin.left, ", ").concat(this._margin.top + topOffset, ")");
+                var xGroup = showX && elem("g.d3plus-plot-x-axis", {
+                    parent: parent,
+                    transition: transition,
+                    enter: {
+                        transform: transform
+                    },
+                    update: {
+                        transform: transform
+                    }
+                });
+                var x2Group = x2Exists && elem("g.d3plus-plot-x2-axis", {
+                    parent: parent,
+                    transition: transition,
+                    enter: {
+                        transform: x2Transform
+                    },
+                    update: {
+                        transform: x2Transform
+                    }
+                });
+                var xTrans = xOffsetLeft > yWidth ? xOffsetLeft - yWidth : 0;
+                var yTransform = "translate(".concat(this._margin.left + xTrans, ", ").concat(this._margin.top + topOffset, ")");
+                var yGroup = showY && elem("g.d3plus-plot-y-axis", {
+                    parent: parent,
+                    transition: transition,
+                    enter: {
+                        transform: yTransform
+                    },
+                    update: {
+                        transform: yTransform
+                    }
+                });
+                var y2Transform = "translate(-".concat(this._margin.right, ", ").concat(this._margin.top + topOffset, ")");
+                var y2Group = y2Exists && elem("g.d3plus-plot-y2-axis", {
+                    parent: parent,
+                    transition: transition,
+                    enter: {
+                        transform: y2Transform
+                    },
+                    update: {
+                        transform: y2Transform
+                    }
+                });
+                this._xAxis.domain(xDomain).height(height - (x2Height + topOffset + verticalMargin)).maxSize(height / 2).range(xRange).select(showX ? xGroup.node() : undefined).ticks(xTicks).width(width).config(xC).config(this._xConfig).scale(xConfigScale).render();
+                if (x2Exists) {
+                    this._x2Axis.domain(x2Domain).height(height - (xHeight + topOffset + verticalMargin)).range(xRange).select(x2Group.node()).ticks(x2Ticks).width(width).config(xC).config(defaultX2Config).config(this._x2Config).scale(x2ConfigScale).render();
+                }
+                this._xFunc = x = function(d, x) {
+                    if (x === "x2") {
+                        if (x2ConfigScale === "log" && d === 0) d = x2Domain[0] < 0 ? _this._x2Axis._d3Scale.domain()[1] : _this._x2Axis._d3Scale.domain()[0];
+                        return _this._x2Axis._getPosition.bind(_this._x2Axis)(d);
+                    } else {
+                        if (xConfigScale === "log" && d === 0) d = xDomain[0] < 0 ? _this._xAxis._d3Scale.domain()[1] : _this._xAxis._d3Scale.domain()[0];
+                        return _this._xAxis._getPosition.bind(_this._xAxis)(d);
+                    }
+                };
+                yRange = [
+                    this._xAxis.outerBounds().y + x2Height,
+                    height - (xHeight + topOffset + verticalMargin)
+                ];
+                this._yAxis.domain(yDomain).height(height).maxSize(width / 2).range(yRange).select(showY ? yGroup.node() : undefined).ticks(yTicks).width(xRange[xRange.length - 1]).config(yC).config(this._yConfig).scale(yConfigScale).render();
+                if (y2Exists) {
+                    this._y2Axis.config(yC).domain(y2Exists ? y2Domain : yDomain).gridSize(0).height(height).range(yRange).select(y2Group.node()).width(width - max([
+                        0,
+                        xOffsetRight - y2Width
+                    ])).title(false).config(this._y2Config).config(defaultY2Config).scale(y2ConfigScale).render();
+                }
+                var labelPositions = {};
+                if (labelWidths) {
+                    nest().key(function(d) {
+                        return d.xValue;
+                    }).entries(labelWidths).forEach(function(param) {
+                        var values = param.values;
+                        var minFontSize = max(values.map(function(d) {
+                            return d.fontSize;
+                        }));
+                        var yBuckets = range(yRange[0], yRange[1], minFontSize).reverse();
+                        var bumpLimit = (yRange[1] - yRange[0]) / 8;
+                        /** */ function bumpPrevious(d, i, arr) {
+                            if (!d.defaultY) d.defaultY = this._yAxis._getPosition(d.value);
+                            if (i) {
+                                var prev = arr[i - 1];
+                                var fontSize = d.fontSize, padding = d.padding;
+                                var y = d.newY || d.defaultY;
+                                var prevY = prev.newY || prev.defaultY;
+                                if (y - fontSize / 2 - padding < prevY) {
+                                    var newY = yBuckets.find(function(n) {
+                                        return n < prevY;
+                                    });
+                                    var change = d.defaultY - newY;
+                                    if (change < bumpLimit) {
+                                        prev.newY = newY;
+                                        if (i) bumpPrevious(prev, i - 1, arr);
+                                    }
+                                }
+                            }
+                        }
+                        values.forEach(bumpPrevious.bind(_this));
+                    });
+                    labelPositions = labelWidths.reduce(function(obj, d) {
+                        if (d.newY) obj[d.id] = d.newY;
+                        return obj;
+                    }, {});
+                }
+                this._yFunc = y = function(d, y) {
+                    if (y === "y2") {
+                        if (y2ConfigScale === "log" && d === 0) d = y2Domain[1] < 0 ? _this._y2Axis._d3ScaleNegative.domain()[0] : _this._y2Axis._d3Scale.domain()[1];
+                        return _this._y2Axis._getPosition.bind(_this._y2Axis)(d) - x2Height;
+                    } else {
+                        if (yConfigScale === "log" && d === 0) d = yDomain[1] < 0 ? _this._yAxis._d3ScaleNegative.domain()[0] : _this._yAxis._d3Scale.domain()[1];
+                        return _this._yAxis._getPosition.bind(_this._yAxis)(d) - x2Height;
+                    }
+                };
+                new shapes.Rect().data([
+                    {}
+                ]).select(rectGroup.node()).x(xRange[0] + (xRange[1] - xRange[0]) / 2).width(xRange[1] - xRange[0]).y(this._margin.top + topOffset + yRange[0] + (yRange[1] - yRange[0]) / 2).height(yRange[1] - yRange[0]).config(this._backgroundConfig).render();
+                var labelConnectors = labelWidths.filter(function(d) {
+                    return d.newY !== undefined;
+                });
+                if (labelConnectors.length) {
+                    var connectorGroup = elem("g.d3plus-plot-connectors", {
+                        parent: parent,
+                        transition: transition,
+                        enter: {
+                            transform: transform
+                        },
+                        update: {
+                            transform: transform
+                        }
+                    }).node();
+                    var data1 = labelConnectors.map(function(d) {
+                        return assign({
+                            x: _this._xAxis._getPosition.bind(_this._xAxis)(d.xValue),
+                            y: d.defaultY
+                        }, d);
+                    }).concat(labelConnectors.map(function(d) {
+                        return assign({
+                            x: _this._xAxis._getPosition.bind(_this._xAxis)(d.xValue) + d.padding - 1,
+                            y: d.newY || d.defaultY
+                        }, d);
+                    }));
+                    new shapes.Line().config({
+                        data: data1,
+                        stroke: function(d) {
+                            return d.fontColor;
+                        },
+                        x: function(d) {
+                            return d.x;
+                        },
+                        y: function(d) {
+                            return d.y;
+                        }
+                    }).config(this._labelConnectorConfig).select(connectorGroup).render();
+                }
+                var annotationGroupBack = elem("g.d3plus-plot-annotations", {
+                    parent: parent,
+                    transition: transition,
+                    enter: {
+                        transform: transform
+                    },
+                    update: {
+                        transform: transform
+                    }
+                }).node();
+                var shapeGroup = elem("g.d3plus-plot-shapes", {
+                    parent: parent,
+                    transition: transition,
+                    enter: {
+                        transform: transform
+                    },
+                    update: {
+                        transform: transform
+                    }
+                }).node();
+                var annotationGroupFront = elem("g.d3plus-plot-annotations-front", {
+                    parent: parent,
+                    transition: transition,
+                    enter: {
+                        transform: transform
+                    },
+                    update: {
+                        transform: transform
+                    }
+                }).node();
+                Object.keys(this._previousAnnotations).forEach(function(layer) {
+                    var group = layer === "front" ? annotationGroupFront : annotationGroupBack;
+                    var annotationData = _this._annotations.filter(function(d) {
+                        return layer === "back" && !d.layer || d.layer === layer;
+                    });
+                    var annotationShapes = annotationData.map(function(d) {
+                        return d.shape;
+                    });
+                    annotationData.forEach(function(annotation) {
+                        new shapes[annotation.shape]().config(annotation).config({
+                            x: function(d) {
+                                return d.x2 ? x(d.x2, "x2") : x(d.x);
+                            },
+                            x0: _this._discrete === "x" ? function(d) {
+                                return d.x2 ? x(d.x2, "x2") : x(d.x);
+                            } : x(domains.x[0]),
+                            x1: _this._discrete === "x" ? null : function(d) {
+                                return d.x2 ? x(d.x2, "x2") : x(d.x);
+                            },
+                            y: function(d) {
+                                return d.y2 ? y(d.y2, "y2") : y(d.y);
+                            },
+                            y0: _this._discrete === "y" ? function(d) {
+                                return d.y2 ? y(d.y2, "y2") : y(d.y);
+                            } : y(domains.y[1]) - yOffset,
+                            y1: _this._discrete === "y" ? null : function(d) {
+                                return d.y2 ? y(d.y2, "y2") : y(d.y) - yOffset;
+                            }
+                        }).select(group).render();
+                    });
+                    var exitAnnotations = _this._previousAnnotations[layer].filter(function(d) {
+                        return !annotationShapes.includes(d);
+                    });
+                    exitAnnotations.forEach(function(shape) {
+                        new shapes[shape]().data([]).select(group).render();
+                    });
+                    _this._previousAnnotations[layer] = annotationShapes;
+                });
+                var yOffset = this._xAxis.barConfig()["stroke-width"];
+                if (yOffset) yOffset /= 2;
+                var discrete1 = this._discrete || "x";
+                var shapeConfig = {
+                    discrete: this._discrete,
+                    duration: this._duration,
+                    label: function(d) {
+                        return _this._drawLabel(d.data, d.i);
+                    },
+                    select: shapeGroup,
+                    x: function(d) {
+                        return d.x2 !== undefined ? x(d.x2, "x2") : x(d.x);
+                    },
+                    x0: discrete1 === "x" ? function(d) {
+                        return d.x2 ? x(d.x2, "x2") : x(d.x);
+                    } : x(typeof this._baseline === "number" ? this._baseline : domains.x[0]),
+                    x1: discrete1 === "x" ? null : function(d) {
+                        return d.x2 ? x(d.x2, "x2") : x(d.x);
+                    },
+                    y: function(d) {
+                        return d.y2 !== undefined ? y(d.y2, "y2") : y(d.y);
+                    },
+                    y0: discrete1 === "y" ? function(d) {
+                        return d.y2 ? y(d.y2, "y2") : y(d.y);
+                    } : y(typeof this._baseline === "number" ? this._baseline : domains.y[1]) - yOffset,
+                    y1: discrete1 === "y" ? null : function(d) {
+                        return d.y2 ? y(d.y2, "y2") : y(d.y) - yOffset;
+                    }
+                };
+                var events = Object.keys(this._on);
+                shapeData.forEach(function(d) {
+                    var _loop = function(e) {
+                        s.on(globalEvents[e], function(d, i, x, event) {
+                            return _this._on[globalEvents[e]](d.data, d.i, x, event);
+                        });
+                    }, _loop1 = function(e1) {
+                        s.on(shapeEvents[e1], function(d, i, x, event) {
+                            return _this._on[shapeEvents[e1]](d.data, d.i, x, event);
+                        });
+                    }, _loop2 = function(e2) {
+                        s.on(classEvents[e2], function(d, i, x, event) {
+                            return _this._on[classEvents[e2]](d.data, d.i, x, event);
+                        });
+                    };
+                    var shapeConfigInner = Object.assign({}, shapeConfig);
+                    if (_this._stacked && [
+                        "Area",
+                        "Bar"
+                    ].includes(d.key)) {
+                        var scale = opp === "x" ? x : y;
+                        shapeConfigInner["".concat(opp)] = shapeConfigInner["".concat(opp, "0")] = function(d) {
+                            var dataIndex = stackKeys.indexOf(d.id), discreteIndex = discreteKeys.indexOf(d.discrete);
+                            var scaleIndex = d[opp] < 0 ? 1 : 0;
+                            return dataIndex >= 0 ? scale(stackData[dataIndex][discreteIndex][scaleIndex]) : scale(domains[opp][opp === "x" ? 0 : 1]);
+                        };
+                        shapeConfigInner["".concat(opp, "1")] = function(d) {
+                            var dataIndex = stackKeys.indexOf(d.id), discreteIndex = discreteKeys.indexOf(d.discrete);
+                            var scaleIndex = d[opp] < 0 ? 0 : 1;
+                            return dataIndex >= 0 ? scale(stackData[dataIndex][discreteIndex][scaleIndex]) : scale(domains[opp][opp === "x" ? 0 : 1]);
+                        };
+                    }
+                    var s = new shapes[d.key]().config(shapeConfigInner).data(d.values);
+                    if (d.key === "Bar") {
+                        var space;
+                        var scale1 = _this._discrete === "x" ? x : y;
+                        var scaleType = _this._discrete === "x" ? xScale : yScale;
+                        var vals = _this._discrete === "x" ? xDomain : yDomain;
+                        var _$range = _this._discrete === "x" ? xRange : yRange;
+                        if (scaleType !== "Point" && vals.length === 2) {
+                            var allPositions = Array.from(new Set(d.values.map(function(d) {
+                                return scale1(d[_this._discrete]);
+                            })));
+                            allPositions.unshift(_$range[0] - allPositions[0] - _$range[0]);
+                            allPositions.push(_$range[1] + _$range[1] - allPositions[allPositions.length - 1]);
+                            space = allPositions.reduce(function(n, d, i, arr) {
+                                if (i) {
+                                    var dist = Math.abs(d - arr[i - 1]);
+                                    if (dist < n) n = dist;
+                                }
+                                return n;
+                            }, Infinity);
+                        } else if (vals.length > 1) space = scale1(vals[1]) - scale1(vals[0]);
+                        else space = _$range[_$range.length - 1] - _$range[0];
+                        if (_this._groupPadding < space) space -= _this._groupPadding;
+                        var barSize = space || 1;
+                        var groups = nest().key(function(d) {
+                            return d[_this._discrete];
+                        }).key(function(d) {
+                            return d.group;
+                        }).entries(d.values);
+                        var ids = merge(groups.map(function(d) {
+                            return d.values.map(function(v) {
+                                return v.key;
+                            });
+                        }));
+                        var uniqueIds = Array.from(new Set(ids));
+                        if (max(groups.map(function(d) {
+                            return d.values.length;
+                        })) === 1) {
+                            s[_this._discrete](function(d, i) {
+                                return shapeConfig[_this._discrete](d, i);
+                            });
+                        } else {
+                            barSize = (barSize - _this._barPadding * uniqueIds.length - 1) / uniqueIds.length;
+                            var offset = space / 2 - barSize / 2;
+                            var xMod = scales.scaleLinear().domain([
+                                0,
+                                uniqueIds.length - 1
+                            ]).range([
+                                -offset,
+                                offset
+                            ]);
+                            s[_this._discrete](function(d, i) {
+                                return shapeConfig[_this._discrete](d, i) + xMod(uniqueIds.indexOf(d.group));
+                            });
+                        }
+                        s.width(barSize);
+                        s.height(barSize);
+                    } else if (d.key === "Line") {
+                        s.duration(width * 1.5);
+                        if (_this._confidence) {
+                            var areaConfig = Object.assign({}, shapeConfig);
+                            var discrete = _this._discrete || "x";
+                            var key = discrete === "x" ? "y" : "x";
+                            var scaleFunction = discrete === "x" ? y : x;
+                            areaConfig["".concat(key, "0")] = function(d) {
+                                return scaleFunction(_this._confidence[0] ? d.lci : d[key]);
+                            };
+                            areaConfig["".concat(key, "1")] = function(d) {
+                                return scaleFunction(_this._confidence[1] ? d.hci : d[key]);
+                            };
+                            var area = new shapes.Area().config(areaConfig).data(d.values);
+                            var confidenceConfig = Object.assign(_this._shapeConfig, _this._confidenceConfig);
+                            area.config(assign(configPrep.bind(_this)(confidenceConfig, "shape", "Line"), configPrep.bind(_this)(confidenceConfig, "shape", "Area"))).render();
+                            _this._shapes.push(area);
+                        }
+                        s.config({
+                            discrete: shapeConfig.discrete || "x",
+                            label: showLineLabels ? function(d, i) {
+                                var visible = typeof _this._lineLabels === "function" ? _this._lineLabels(d.data, d.i) : true;
+                                if (!visible) return false;
+                                var labelData = labelWidths.find(function(l) {
+                                    return l.id === d.id;
+                                });
+                                if (labelData) {
+                                    var yPos = labelData.newY || labelData.defaultY;
+                                    var allLabels = labelWidths.filter(function(l) {
+                                        return l.newY === yPos;
+                                    });
+                                    if (allLabels.length > 1) return allLabels[0].id !== d.id ? false : "+".concat(formatAbbreviate(allLabels.length, _this._locale), " ").concat(_this._translate("more"));
+                                    return _this._drawLabel(d, i);
+                                }
+                                return false;
+                            } : false,
+                            labelBounds: showLineLabels ? function(d, i, s) {
+                                var _s_points_ = _sliced_to_array(s.points[0], 2), firstX = _s_points_[0], firstY = _s_points_[1];
+                                var _s_points_1 = _sliced_to_array(s.points[s.points.length - 1], 2), lastX = _s_points_1[0], lastY = _s_points_1[1];
+                                var height = _this._height / 4;
+                                var mod = labelPositions[d.id] ? lastY - labelPositions[d.id] : 0;
+                                return {
+                                    x: lastX - firstX,
+                                    y: lastY - firstY - height / 2 - mod,
+                                    width: largestLabel,
+                                    height: height
+                                };
+                            } : false
+                        });
+                    }
+                    var classEvents = events.filter(function(e) {
+                        return e.includes(".".concat(d.key));
+                    }), globalEvents = events.filter(function(e) {
+                        return !e.includes(".");
+                    }), shapeEvents = events.filter(function(e) {
+                        return e.includes(".shape");
+                    });
+                    for(var e = 0; e < globalEvents.length; e++)_loop(e);
+                    for(var e1 = 0; e1 < shapeEvents.length; e1++)_loop1(e1);
+                    for(var e2 = 0; e2 < classEvents.length; e2++)_loop2(e2);
+                    var userConfig = configPrep.bind(_this)(_this._shapeConfig, "shape", d.key);
+                    if (_this._shapeConfig.duration === undefined) delete userConfig.duration;
+                    s.config(userConfig).render();
+                    _this._shapes.push(s);
+                    if (d.key === "Line") {
+                        var _loop3 = function(e3) {
+                            markers.on(globalEvents[e3], function(d, i, x, event) {
+                                return _this._on[globalEvents[e3]](d.data, d.i, x, event);
+                            });
+                        }, _loop4 = function(e4) {
+                            markers.on(shapeEvents[e4], function(d, i, x, event) {
+                                return _this._on[shapeEvents[e4]](d.data, d.i, x, event);
+                            });
+                        }, _loop5 = function(e5) {
+                            markers.on(classEvents[e5], function(d, i, x, event) {
+                                return _this._on[classEvents[e5]](d.data, d.i, x, event);
+                            });
+                        };
+                        var markers = new shapes.Circle().data(_this._lineMarkers ? d.values : []).config(shapeConfig).config(_this._lineMarkerConfig).id(function(d) {
+                            return "".concat(d.id, "_").concat(d.discrete);
+                        });
+                        for(var e3 = 0; e3 < globalEvents.length; e3++)_loop3(e3);
+                        for(var e4 = 0; e4 < shapeEvents.length; e4++)_loop4(e4);
+                        for(var e5 = 0; e5 < classEvents.length; e5++)_loop5(e5);
+                        markers.render();
+                        _this._shapes.push(markers);
+                    }
+                });
+                var dataShapes = shapeData.map(function(d) {
+                    return d.key;
+                });
+                if (dataShapes.includes("Line")) {
+                    if (this._confidence) dataShapes.push("Area");
+                    if (this._lineMarkers) dataShapes.push("Circle");
+                }
+                var exitShapes = this._previousShapes.filter(function(d) {
+                    return !dataShapes.includes(d);
+                });
+                exitShapes.forEach(function(shape) {
+                    new shapes[shape]().config(shapeConfig).data([]).render();
+                });
+                this._previousShapes = dataShapes;
+                return this;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Allows drawing custom shapes to be used as annotations in the provided x/y plot. This method accepts custom config objects for the [Shape](http://d3plus.org/docs/#Shape) class, either a single config object or an array of config objects. Each config object requires an additional parameter, the "shape", which denotes which [Shape](http://d3plus.org/docs/#Shape) sub-class to use ([Rect](http://d3plus.org/docs/#Rect), [Line](http://d3plus.org/docs/#Line), etc).
+
+Additionally, each config object can also contain an optional "layer" key, which defines whether the annotations will be displayed in "front" or in "back" of the primary visualization shapes. This value defaults to "back" if not present.
+      @param {Array|Object} *annotations* = []
+      @chainable
+  */ key: "annotations",
+            value: function annotations(_) {
+                return arguments.length ? (this._annotations = _instanceof(_, Array) ? _ : [
+                    _
+                ], this) : this._annotations;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Determines whether the x and y axes should have their scales persist while users filter the data, the timeline being the prime example (set this to `true` to make the axes stay consistent when the timeline changes).
+      @param {Boolean} [*value* = false]
+      @chainable
+  */ key: "axisPersist",
+            value: function axisPersist(_) {
+                return arguments.length ? (this._axisPersist = _, this) : this._axisPersist;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc A d3plus-shape configuration Object used for styling the background rectangle of the inner x/y plot (behind all of the shapes and gridlines).
+       @param {Object} [*value*]
+       @chainable
+   */ key: "backgroundConfig",
+            value: function backgroundConfig(_) {
+                return arguments.length ? (this._backgroundConfig = assign(this._backgroundConfig, _), this) : this._backgroundConfig;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the pixel space between each bar in a group of bars.
+      @param {Number} *value* = 0
+      @chainable
+  */ key: "barPadding",
+            value: function barPadding(_) {
+                return arguments.length ? (this._barPadding = _, this) : this._barPadding;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the baseline for the x/y plot. If *value* is not specified, returns the current baseline.
+      @param {Number} *value*
+      @chainable
+  */ key: "baseline",
+            value: function baseline(_) {
+                return arguments.length ? (this._baseline = _, this) : this._baseline;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc Determines whether or not to add additional padding at the ends of x or y scales. The most commone use for this is in Scatter Plots, so that the shapes do not appear directly on the axis itself. The value provided can either be `true` or `false` to toggle the behavior for all shape types, or a keyed Object for each shape type (ie. `{Bar: false, Circle: true, Line: false}`).
+       @param {Object|Boolean} [*value*]
+       @chainable
+   */ key: "buffer",
+            value: function buffer(_) {
+                if (arguments.length) {
+                    if (!_) this._buffer = {};
+                    else if (_ === true) this._buffer = defaultBuffers;
+                    else {
+                        this._buffer = assign({}, this._buffer, _);
+                        for(var key in this._buffer){
+                            if (this._buffer[key] === true) this._buffer[key] = defaultBuffers[key];
+                        }
+                    }
+                    return this;
+                }
+                return this._buffer;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc Sets the confidence to the specified array of lower and upper bounds.
+       @param {String[]|Function[]} *value*
+       @chainable
+       @example <caption>Can be called with accessor functions or static keys:</caption>
+       var data = {id: "alpha", value: 10, lci: 9, hci: 11};
+       ...
+       // Accessor functions
+       .confidence([function(d) { return d.lci }, function(d) { return d.hci }])
+
+       // Or static keys
+       .confidence(["lci", "hci"])
+   */ key: "confidence",
+            value: function confidence(_) {
+                if (arguments.length && _instanceof(_, Array)) {
+                    this._confidence = [];
+                    var lower = _[0];
+                    this._confidence[0] = typeof lower === "function" || !lower ? lower : accessor(lower);
+                    var upper = _[1];
+                    this._confidence[1] = typeof upper === "function" || !upper ? upper : accessor(upper);
+                    return this;
+                } else return this._confidence;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc If *value* is specified, sets the config method for each shape rendered as a confidence interval and returns the current class instance.
+       @param {Object} [*value*]
+       @chainable
+   */ key: "confidenceConfig",
+            value: function confidenceConfig(_) {
+                return arguments.length ? (this._confidenceConfig = assign(this._confidenceConfig, _), this) : this._confidenceConfig;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the discrete axis to the specified string. If *value* is not specified, returns the current discrete axis.
+      @param {String} *value*
+      @chainable
+  */ key: "discrete",
+            value: function discrete(_) {
+                return arguments.length ? (this._discrete = _, this) : this._discrete;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc When the width or height of the chart is less than or equal to this pixel value, the discrete axis will not be shown. This helps produce slick sparklines. Set this value to `0` to disable the behavior entirely.
+      @param {Number} *value*
+      @chainable
+  */ key: "discreteCutoff",
+            value: function discreteCutoff(_) {
+                return arguments.length ? (this._discreteCutoff = _, this) : this._discreteCutoff;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the pixel space between groups of bars.
+      @param {Number} [*value* = 5]
+      @chainable
+  */ key: "groupPadding",
+            value: function groupPadding(_) {
+                return arguments.length ? (this._groupPadding = _, this) : this._groupPadding;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc The d3plus-shape config used on the Line shapes created to connect lineLabels to the end of their associated Line path.
+       @param {Object} [*value*]
+       @chainable
+   */ key: "labelConnectorConfig",
+            value: function labelConnectorConfig(_) {
+                return arguments.length ? (this._labelConnectorConfig = assign(this._labelConnectorConfig, _), this) : this._labelConnectorConfig;
+            }
+        },
+        {
+            /**
+      @memberof Viz
+      @desc The behavior to be used when calculating the position and size of each shape's label(s). The value passed can either be the _String_ name of the behavior to be used for all shapes, or an accessor _Function_ that will be provided each data point and will be expected to return the behavior to be used for that data point. The availability and options for this method depend on the default logic for each Shape. As an example, the values "outside" or "inside" can be set for Bar shapes, whose "auto" default will calculate the best position dynamically based on the available space.
+      @param {Function|String} [*value* = "auto"]
+      @chainable
+  */ key: "labelPosition",
+            value: function labelPosition(_) {
+                return arguments.length ? (this._labelPosition = typeof _ === "function" ? _ : constant(_), this) : this._labelPosition;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Draws labels on the right side of any Line shapes that are drawn on the plot.
+      @param {Boolean|Function} [*value* = false]
+      @chainable
+  */ key: "lineLabels",
+            value: function lineLabels(_) {
+                return arguments.length ? (this._lineLabels = _, this) : this._lineLabels;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Shape config for the Circle shapes drawn by the lineMarkers method.
+      @param {Object} *value*
+      @chainable
+  */ key: "lineMarkerConfig",
+            value: function lineMarkerConfig(_) {
+                return arguments.length ? (this._lineMarkerConfig = assign(this._lineMarkerConfig, _), this) : this._lineMarkerConfig;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Draws circle markers on each vertex of a Line.
+      @param {Boolean} [*value* = false]
+      @chainable
+  */ key: "lineMarkers",
+            value: function lineMarkers(_) {
+                return arguments.length ? (this._lineMarkers = _, this) : this._lineMarkers;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc A JavaScript [sort comparator function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) that receives each shape Class (ie. "Circle", "Line", etc) as it's comparator arguments. Shapes are drawn in groups based on their type, so you are defining the layering order for all shapes of said type.
+      @param {Function} *value*
+      @chainable
+  */ key: "shapeSort",
+            value: function shapeSort(_) {
+                return arguments.length ? (this._shapeSort = _, this) : this._shapeSort;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the size of bubbles to the given Number, data key, or function.
+      @param {Function|Number|String} *value* = 10
+      @chainable
+  */ key: "size",
+            value: function size(_) {
+                return arguments.length ? (this._size = typeof _ === "function" || !_ ? _ : accessor(_), this) : this._size;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the size scale maximum to the specified number.
+      @param {Number} *value* = 20
+      @chainable
+  */ key: "sizeMax",
+            value: function sizeMax(_) {
+                return arguments.length ? (this._sizeMax = _, this) : this._sizeMax;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the size scale minimum to the specified number.
+      @param {Number} *value* = 5
+      @chainable
+  */ key: "sizeMin",
+            value: function sizeMin(_) {
+                return arguments.length ? (this._sizeMin = _, this) : this._sizeMin;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the size scale to the specified string.
+      @param {String} *value* = "sqrt"
+      @chainable
+  */ key: "sizeScale",
+            value: function sizeScale(_) {
+                return arguments.length ? (this._sizeScale = _, this) : this._sizeScale;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc If *value* is specified, toggles shape stacking. If *value* is not specified, returns the current stack value.
+      @param {Boolean} *value* = false
+      @chainable
+  */ key: "stacked",
+            value: function stacked(_) {
+                return arguments.length ? (this._stacked = _, this) : this._stacked;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the stack offset. If *value* is not specified, returns the current stack offset function.
+      @param {Function|String} *value* = "descending"
+      @chainable
+  */ key: "stackOffset",
+            value: function stackOffset(_) {
+                return arguments.length ? (this._stackOffset = typeof _ === "function" ? _ : d3Shape["stackOffset".concat(_.charAt(0).toUpperCase() + _.slice(1))], this) : this._stackOffset;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the stack order. If *value* is not specified, returns the current stack order function.
+      @param {Function|String|Array} *value* = "none"
+      @chainable
+  */ key: "stackOrder",
+            value: function stackOrder(_) {
+                if (arguments.length) {
+                    if (typeof _ === "string") this._stackOrder = _ === "ascending" ? stackOrderAscending : _ === "descending" ? stackOrderDescending : d3Shape["stackOrder".concat(_.charAt(0).toUpperCase() + _.slice(1))];
+                    else this._stackOrder = _;
+                    return this;
+                } else return this._stackOrder;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the x accessor to the specified function or number. If *value* is not specified, returns the current x accessor.
+      @param {Function|Number} *value*
+      @chainable
+  */ key: "x",
+            value: function x(_) {
+                if (arguments.length) {
+                    if (typeof _ === "function") this._x = _;
+                    else {
+                        this._x = accessor(_);
+                        this._xKey = _;
+                    }
+                    return this;
+                } else return this._x;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc Sets the x2 accessor to the specified function or number. If *value* is not specified, returns the current x2 accessor.
+       @param {Function|Number} *value*
+       @chainable
+   */ key: "x2",
+            value: function x2(_) {
+                if (arguments.length) {
+                    if (typeof _ === "function") this._x2 = _;
+                    else {
+                        this._x2 = accessor(_);
+                        this._x2Key = _;
+                    }
+                    return this;
+                } else return this._x2;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the x-axis. Includes additional functionality where passing "auto" as the value for the [scale](http://d3plus.org/docs/#Axis.scale) method will determine if the scale should be "linear" or "log" based on the provided data.
+      @param {Object} *value*
+      @chainable
+  */ key: "xConfig",
+            value: function xConfig(_) {
+                return arguments.length ? (this._xConfig = assign(this._xConfig, _), this) : this._xConfig;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc When the width of the chart is less than or equal to this pixel value, and the x-axis is not the discrete axis, it will not be shown. This helps produce slick sparklines. Set this value to `0` to disable the behavior entirely.
+      @param {Number} *value*
+      @chainable
+  */ key: "xCutoff",
+            value: function xCutoff(_) {
+                return arguments.length ? (this._xCutoff = _, this) : this._xCutoff;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the secondary x-axis. Includes additional functionality where passing "auto" as the value for the [scale](http://d3plus.org/docs/#Axis.scale) method will determine if the scale should be "linear" or "log" based on the provided data.
+      @param {Object} *value*
+      @chainable
+  */ key: "x2Config",
+            value: function x2Config(_) {
+                return arguments.length ? (this._x2Config = assign(this._x2Config, _), this) : this._x2Config;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the x domain to the specified array. If *value* is not specified, returns the current x domain. Additionally, if either value of the array is undefined, it will be calculated from the data.
+      @param {Array} *value*
+      @chainable
+  */ key: "xDomain",
+            value: function xDomain(_) {
+                return arguments.length ? (this._xDomain = _, this) : this._xDomain;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc Sets the x2 domain to the specified array. If *value* is not specified, returns the current x2 domain. Additionally, if either value of the array is undefined, it will be calculated from the data.
+       @param {Array} *value*
+       @chainable
+   */ key: "x2Domain",
+            value: function x2Domain(_) {
+                return arguments.length ? (this._x2Domain = _, this) : this._x2Domain;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Defines a custom sorting comparitor function to be used for discrete x axes.
+      @param {Function} *value*
+      @chainable
+  */ key: "xSort",
+            value: function xSort(_) {
+                return arguments.length ? (this._xSort = _, this) : this._xSort;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc Defines a custom sorting comparitor function to be used for discrete x2 axes.
+       @param {Function} *value*
+       @chainable
+   */ key: "x2Sort",
+            value: function x2Sort(_) {
+                return arguments.length ? (this._x2Sort = _, this) : this._x2Sort;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the y accessor to the specified function or number. If *value* is not specified, returns the current y accessor.
+      @param {Function|Number} *value*
+      @chainable
+  */ key: "y",
+            value: function y(_) {
+                if (arguments.length) {
+                    if (typeof _ === "function") this._y = _;
+                    else {
+                        this._y = accessor(_);
+                        this._yKey = _;
+                    }
+                    return this;
+                } else return this._y;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc Sets the y2 accessor to the specified function or number. If *value* is not specified, returns the current y2 accessor.
+       @param {Function|Number} *value*
+       @chainable
+   */ key: "y2",
+            value: function y2(_) {
+                if (arguments.length) {
+                    if (typeof _ === "function") this._y2 = _;
+                    else {
+                        this._y2 = accessor(_);
+                        this._y2Key = _;
+                    }
+                    return this;
+                } else return this._y2;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the y-axis. Includes additional functionality where passing "auto" as the value for the [scale](http://d3plus.org/docs/#Axis.scale) method will determine if the scale should be "linear" or "log" based on the provided data.
+
+*Note:* If a "domain" array is passed to the y-axis config, it will be reversed.
+      @param {Object} *value*
+      @chainable
+  */ key: "yConfig",
+            value: function yConfig(_) {
+                if (arguments.length) {
+                    if (_.domain) _.domain = _.domain.slice().reverse();
+                    this._yConfig = assign(this._yConfig, _);
+                    return this;
+                }
+                return this._yConfig;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc When the height of the chart is less than or equal to this pixel value, and the y-axis is not the discrete axis, it will not be shown. This helps produce slick sparklines. Set this value to `0` to disable the behavior entirely.
+      @param {Number} *value*
+      @chainable
+  */ key: "yCutoff",
+            value: function yCutoff(_) {
+                return arguments.length ? (this._yCutoff = _, this) : this._yCutoff;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the secondary y-axis. Includes additional functionality where passing "auto" as the value for the [scale](http://d3plus.org/docs/#Axis.scale) method will determine if the scale should be "linear" or "log" based on the provided data.
+      @param {Object} *value*
+      @chainable
+  */ key: "y2Config",
+            value: function y2Config(_) {
+                if (arguments.length) {
+                    if (_.domain) _.domain = _.domain.slice().reverse();
+                    this._y2Config = assign(this._y2Config, _);
+                    return this;
+                }
+                return this._y2Config;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Sets the y domain to the specified array. If *value* is not specified, returns the current y domain. Additionally, if either value of the array is undefined, it will be calculated from the data.
+      @param {Array} *value*
+      @chainable
+  */ key: "yDomain",
+            value: function yDomain(_) {
+                return arguments.length ? (this._yDomain = _, this) : this._yDomain;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc Sets the y2 domain to the specified array. If *value* is not specified, returns the current y2 domain. Additionally, if either value of the array is undefined, it will be calculated from the data.
+       @param {Array} *value*
+       @chainable
+   */ key: "y2Domain",
+            value: function y2Domain(_) {
+                return arguments.length ? (this._y2Domain = _, this) : this._y2Domain;
+            }
+        },
+        {
+            /**
+      @memberof Plot
+      @desc Defines a custom sorting comparitor function to be used for discrete y axes.
+      @param {Function} *value*
+      @chainable
+  */ key: "ySort",
+            value: function ySort(_) {
+                return arguments.length ? (this._ySort = _, this) : this._ySort;
+            }
+        },
+        {
+            /**
+       @memberof Plot
+       @desc Defines a custom sorting comparitor function to be used for discrete y2 axes.
+       @param {Function} *value*
+       @chainable
+   */ key: "y2Sort",
+            value: function y2Sort(_) {
+                return arguments.length ? (this._y2Sort = _, this) : this._y2Sort;
+            }
+        }
+    ]);
+    return Plot;
+}(Viz);
+/**
+    @class Plot
+    @extends Viz
+    @desc Creates an x/y plot based on an array of data.
+*/ export { Plot as default };