Separete src files

Gruntfile.coffee

@@ -9,15 +9,48 @@ module.exports = (grunt) ->
 
         concat:
           dist:
+            options:
+              process: (src, filepath) ->
+                if filepath != 'src/head.js' && filepath != 'src/tail.js'
+                  lines = []
+                  src.split('\n').forEach (line) ->
+                    lines.push( (if line.length > 0 then '    ' else '') + line)
+                  src = lines.join('\n')
+                return src
             src: [
               'src/head.js',
-              'src/c3.core.js',
-              'src/c3.render.bar.js',
-              'src/c3.draw.bar.js',
+              'src/core.js',
+              'src/config.js',
+              'src/scale.js',
+              'src/domain.js',
+              'src/data.js',
+              'src/data.convert.js',
+              'src/data.load.js',
+              'src/category.js',
+              'src/size.js',
+              'src/shape.js',
+              'src/text.js',
+              'src/type.js',
+              'src/grid.js',
+              'src/tooltip.js',
+              'src/legend.js',
+              'src/axis.js',
+              'src/clip.js',
+              'src/arc.js',
+              'src/region.js',
+              'src/drag.js',
+              'src/subchart.js',
+              'src/zoom.js',
+              'src/color.js',
+              'src/format.js',
+              'src/cache.js',
+              'src/class.js',
+              'src/util.js',
+              'src/api.js',
               'src/c3.axis.js',
               'src/tail.js'
             ]
-            dest: 'dist/c3.js'
+            dest: 'c3.js'
 
         jshint:
           c3: 'c3.js'
@@ -36,4 +69,4 @@ module.exports = (grunt) ->
             files:
               'c3.min.js': 'c3.js'
 
-    grunt.registerTask 'default', ['jshint', 'jasmine', 'uglify']
+    grunt.registerTask 'default', ['concat', 'jshint', 'jasmine', 'uglify']

src/c3.axis.js

+// Features:
+// 1. category axis
+// 2. ceil values of translate/x/y to int for half pixel antialiasing
+function c3_axis(d3, isCategory) {
+    var scale = d3.scale.linear(), orient = "bottom", innerTickSize = 6, outerTickSize = 6, tickPadding = 3, tickValues = null, tickFormat, tickArguments;
+
+    var tickOffset = 0, tickCulling = true, tickCentered;
+
+    function axisX(selection, x) {
+        selection.attr("transform", function (d) {
+            return "translate(" + Math.ceil(x(d) + tickOffset) + ", 0)";
+        });
+    }
+    function axisY(selection, y) {
+        selection.attr("transform", function (d) {
+            return "translate(0," + Math.ceil(y(d)) + ")";
+        });
+    }
+    function scaleExtent(domain) {
+        var start = domain[0], stop = domain[domain.length - 1];
+        return start < stop ? [ start, stop ] : [ stop, start ];
+    }
+    function generateTicks(scale) {
+        var i, domain, ticks = [];
+        if (scale.ticks) {
+            return scale.ticks.apply(scale, tickArguments);
+        }
+        domain = scale.domain();
+        for (i = Math.ceil(domain[0]); i < domain[1]; i++) {
+            ticks.push(i);
+        }
+        if (ticks.length > 0 && ticks[0] > 0) {
+            ticks.unshift(ticks[0] - (ticks[1] - ticks[0]));
+        }
+        return ticks;
+    }
+    function copyScale() {
+        var newScale = scale.copy(), domain;
+        if (isCategory) {
+            domain = scale.domain();
+            newScale.domain([domain[0], domain[1] - 1]);
+        }
+        return newScale;
+    }
+    function textFormatted(v) {
+        return tickFormat ? tickFormat(v) : v;
+    }
+    function axis(g) {
+        g.each(function () {
+            var g = d3.select(this);
+            var scale0 = this.__chart__ || scale, scale1 = this.__chart__ = copyScale();
+
+            var ticks = tickValues ? tickValues : generateTicks(scale1),
+                tick = g.selectAll(".tick").data(ticks, scale1),
+                tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", 1e-6),
+                // MEMO: No exit transition. The reason is this transition affects max tick width calculation because old tick will be included in the ticks.
+                tickExit = tick.exit().remove(),
+                tickUpdate = d3.transition(tick).style("opacity", 1),
+                tickTransform, tickX;
+
+            var range = scale.rangeExtent ? scale.rangeExtent() : scaleExtent(scale.range()),
+                path = g.selectAll(".domain").data([ 0 ]),
+                pathUpdate = (path.enter().append("path").attr("class", "domain"), d3.transition(path));
+            tickEnter.append("line");
+            tickEnter.append("text");
+
+            var lineEnter = tickEnter.select("line"),
+                lineUpdate = tickUpdate.select("line"),
+                text = tick.select("text").text(textFormatted),
+                textEnter = tickEnter.select("text"),
+                textUpdate = tickUpdate.select("text");
+
+            if (isCategory) {
+                tickOffset = Math.ceil((scale1(1) - scale1(0)) / 2);
+                tickX = tickCentered ? 0 : tickOffset;
+            } else {
+                tickOffset = tickX = 0;
+            }
+
+            function tickSize(d) {
+                var tickPosition = scale(d) + tickOffset;
+                return range[0] < tickPosition && tickPosition < range[1] ? innerTickSize : 0;
+            }
+
+            switch (orient) {
+            case "bottom":
+                {
+                    tickTransform = axisX;
+                    lineEnter.attr("y2", innerTickSize);
+                    textEnter.attr("y", Math.max(innerTickSize, 0) + tickPadding);
+                    lineUpdate.attr("x1", tickX).attr("x2", tickX).attr("y2", tickSize);
+                    textUpdate.attr("x", 0).attr("y", Math.max(innerTickSize, 0) + tickPadding);
+                    text.attr("dy", ".71em").style("text-anchor", "middle");
+                    pathUpdate.attr("d", "M" + range[0] + "," + outerTickSize + "V0H" + range[1] + "V" + outerTickSize);
+                    break;
+                }
+            case "top":
+                {
+                    tickTransform = axisX;
+                    lineEnter.attr("y2", -innerTickSize);
+                    textEnter.attr("y", -(Math.max(innerTickSize, 0) + tickPadding));
+                    lineUpdate.attr("x2", 0).attr("y2", -innerTickSize);
+                    textUpdate.attr("x", 0).attr("y", -(Math.max(innerTickSize, 0) + tickPadding));
+                    text.attr("dy", "0em").style("text-anchor", "middle");
+                    pathUpdate.attr("d", "M" + range[0] + "," + -outerTickSize + "V0H" + range[1] + "V" + -outerTickSize);
+                    break;
+                }
+            case "left":
+                {
+                    tickTransform = axisY;
+                    lineEnter.attr("x2", -innerTickSize);
+                    textEnter.attr("x", -(Math.max(innerTickSize, 0) + tickPadding));
+                    lineUpdate.attr("x2", -innerTickSize).attr("y2", 0);
+                    textUpdate.attr("x", -(Math.max(innerTickSize, 0) + tickPadding)).attr("y", tickOffset);
+                    text.attr("dy", ".32em").style("text-anchor", "end");
+                    pathUpdate.attr("d", "M" + -outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + -outerTickSize);
+                    break;
+                }
+            case "right":
+                {
+                    tickTransform = axisY;
+                    lineEnter.attr("x2", innerTickSize);
+                    textEnter.attr("x", Math.max(innerTickSize, 0) + tickPadding);
+                    lineUpdate.attr("x2", innerTickSize).attr("y2", 0);
+                    textUpdate.attr("x", Math.max(innerTickSize, 0) + tickPadding).attr("y", 0);
+                    text.attr("dy", ".32em").style("text-anchor", "start");
+                    pathUpdate.attr("d", "M" + outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + outerTickSize);
+                    break;
+                }
+            }
+            if (scale1.rangeBand) {
+                var x = scale1, dx = x.rangeBand() / 2;
+                scale0 = scale1 = function (d) {
+                    return x(d) + dx;
+                };
+            } else if (scale0.rangeBand) {
+                scale0 = scale1;
+            } else {
+                tickExit.call(tickTransform, scale1);
+            }
+            tickEnter.call(tickTransform, scale0);
+            tickUpdate.call(tickTransform, scale1);
+        });
+    }
+    axis.scale = function (x) {
+        if (!arguments.length) { return scale; }
+        scale = x;
+        return axis;
+    };
+    axis.orient = function (x) {
+        if (!arguments.length) { return orient; }
+        orient = x in {top: 1, right: 1, bottom: 1, left: 1} ? x + "" : "bottom";
+        return axis;
+    };
+    axis.tickFormat = function (format) {
+        if (!arguments.length) { return tickFormat; }
+        tickFormat = format;
+        return axis;
+    };
+    axis.tickCentered = function (isCentered) {
+        if (!arguments.length) { return tickCentered; }
+        tickCentered = isCentered;
+        return axis;
+    };
+    axis.tickOffset = function () { // This will be overwritten when normal x axis
+        return tickOffset;
+    };
+    axis.ticks = function () {
+        if (!arguments.length) { return tickArguments; }
+        tickArguments = arguments;
+        return axis;
+    };
+    axis.tickCulling = function (culling) {
+        if (!arguments.length) { return tickCulling; }
+        tickCulling = culling;
+        return axis;
+    };
+    axis.tickValues = function (x) {
+        if (!arguments.length) { return tickValues; }
+        tickValues = x;
+        return axis;
+    };
+    return axis;
+}

src/cache.js

+c3_chart_internal_fn.hasCaches = function (ids) {
+    for (var i = 0; i < ids.length; i++) {
+        if (! (ids[i] in this.cache)) { return false; }
+    }
+    return true;
+};
+c3_chart_internal_fn.addCache = function (id, target) {
+    this.cache[id] = this.cloneTarget(target);
+};
+c3_chart_internal_fn.getCaches = function (ids) {
+    var targets = [], i;
+    for (i = 0; i < ids.length; i++) {
+        if (ids[i] in this.cache) { targets.push(this.cloneTarget(this.cache[ids[i]])); }
+    }
+    return targets;
+};

src/category.js

+c3_chart_internal_fn.categoryName = function (i) {
+    var config = this.config;
+    return i < config[__axis_x_categories].length ? config[__axis_x_categories][i] : i;
+};

src/class.js

+var _target = 'target',
+    _chart  = 'chart ',
+    _chartLine = 'chartLine',
+    _chartLines = 'chartLines',
+    _chartBar = 'chartBar',
+    _chartBars = 'chartBars',
+    _chartText = 'chartText',
+    _chartTexts = 'chartTexts',
+    _chartArc = 'chartArc',
+    _chartArcs = 'chartArcs',
+    _chartArcsTitle = 'chartArcsTitle',
+    _chartArcsBackground = 'chartArcsBackground',
+    _chartArcsGaugeUnit = 'chartArcsGaugeUnit',
+    _chartArcsGaugeMax = 'chartArcsGaugeMax',
+    _chartArcsGaugeMin = 'chartArcsGaugeMin',
+    _selectedCircle = 'selectedCircle',
+    _selectedCircles = 'selectedCircles',
+    _eventRect = 'eventRect',
+    _eventRects = 'eventRects',
+    _eventRectsSingle = 'eventRectsSingle',
+    _eventRectsMultiple = 'eventRectsMultiple',
+    _zoomRect = 'zoomRect',
+    _brush = 'brush',
+    _focused = 'focused',
+    _region = 'region',
+    _regions = 'regions',
+    _tooltip = 'tooltip',
+    _tooltipName = 'tooltipName',
+    _shape = 'shape',
+    _shapes = 'shapes',
+    _line = 'line',
+    _lines = 'lines',
+    _bar = 'bar',
+    _bars = 'bars',
+    _circle = 'circle',
+    _circles = 'circles',
+    _arc = 'arc',
+    _arcs = 'arcs',
+    _area = 'area',
+    _areas = 'areas',
+    _empty = 'empty',
+    _text = 'text',
+    _texts = 'texts',
+    _gaugeValue = 'gaugeValue',
+    _grid = 'grid',
+    _xgrid = 'xgrid',
+    _xgrids = 'xgrids',
+    _xgridLine = 'xgridLine',
+    _xgridLines = 'xgridLines',
+    _xgridFocus = 'xgridFocus',
+    _ygrid = 'ygrid',
+    _ygrids = 'ygrids',
+    _ygridLine = 'ygridLine',
+    _ygridLines = 'ygridLines',
+    _axis = 'axis',
+    _axisX = 'axisX',
+    _axisXLabel = 'axisXLabel',
+    _axisY = 'axisY',
+    _axisYLabel = 'axisYLabel',
+    _axisY2 = 'axisY2',
+    _axisY2Label = 'axisY2Label',
+    _legendBackground = 'legendBackground',
+    _legendItem = 'legendItem',
+    _legendItemEvent = 'legendItemEvent',
+    _legendItemTile = 'legendItemTile',
+    _legendItemHidden = 'legendItemHidden',
+    _legendItemFocused = 'legendItemFocused',
+    _dragarea = 'dragarea',
+    _EXPANDED = 'EXPANDED',
+    _SELECTED = 'SELECTED',
+    _INCLUDED = 'INCLUDED';
+
+var CLASS = c3_chart_internal_fn.CLASS = {};
+CLASS[_target] = 'c3-target';
+CLASS[_chart] = 'c3-chart';
+CLASS[_chartLine] = 'c3-chart-line';
+CLASS[_chartLines] = 'c3-chart-lines';
+CLASS[_chartBar] = 'c3-chart-bar';
+CLASS[_chartBars] = 'c3-chart-bars';
+CLASS[_chartText] = 'c3-chart-text';
+CLASS[_chartTexts] = 'c3-chart-texts';
+CLASS[_chartArc] = 'c3-chart-arc';
+CLASS[_chartArcs] = 'c3-chart-arcs';
+CLASS[_chartArcsTitle] = 'c3-chart-arcs-title';
+CLASS[_chartArcsBackground] = 'c3-chart-arcs-background';
+CLASS[_chartArcsGaugeUnit] = 'c3-chart-arcs-gauge-unit';
+CLASS[_chartArcsGaugeMax] = 'c3-chart-arcs-gauge-max';
+CLASS[_chartArcsGaugeMin] = 'c3-chart-arcs-gauge-min';
+CLASS[_selectedCircle] = 'c3-selected-circle';
+CLASS[_selectedCircles] = 'c3-selected-circles';
+CLASS[_eventRect] = 'c3-event-rect';
+CLASS[_eventRects] = 'c3-event-rects';
+CLASS[_eventRectsSingle] = 'c3-event-rects-single';
+CLASS[_eventRectsMultiple] = 'c3-event-rects-multiple';
+CLASS[_zoomRect] = 'c3-zoom-rect';
+CLASS[_brush] = 'c3-brush';
+CLASS[_focused] = 'c3-focused';
+CLASS[_region] = 'c3-region';
+CLASS[_regions] = 'c3-regions';
+CLASS[_tooltip] = 'c3-tooltip';
+CLASS[_tooltipName] = 'c3-tooltip-name';
+CLASS[_shape] = 'c3-shape';
+CLASS[_shapes] = 'c3-shapes';
+CLASS[_line] = 'c3-line';
+CLASS[_lines] = 'c3-lines';
+CLASS[_bar] = 'c3-bar';
+CLASS[_bars] = 'c3-bars';
+CLASS[_circle] = 'c3-circle';
+CLASS[_circles] = 'c3-circles';
+CLASS[_arc] = 'c3-arc';
+CLASS[_arcs] = 'c3-arcs';
+CLASS[_area] = 'c3-area';
+CLASS[_areas] = 'c3-areas';
+CLASS[_empty] = 'c3-empty';
+CLASS[_text] = 'c3-text';
+CLASS[_texts] = 'c3-texts';
+CLASS[_gaugeValue] = 'c3-gauge-value';
+CLASS[_grid] = 'c3-grid';
+CLASS[_xgrid] = 'c3-xgrid';
+CLASS[_xgrids] = 'c3-xgrids';
+CLASS[_xgridLine] = 'c3-xgrid-line';
+CLASS[_xgridLines] = 'c3-xgrid-lines';
+CLASS[_xgridFocus] = 'c3-xgrid-focus';
+CLASS[_ygrid] = 'c3-ygrid';
+CLASS[_ygrids] = 'c3-ygrids';
+CLASS[_ygridLine] = 'c3-ygrid-line';
+CLASS[_ygridLines] = 'c3-ygrid-lines';
+CLASS[_axis] = 'c3-axis';
+CLASS[_axisX] = 'c3-axis-x';
+CLASS[_axisXLabel] = 'c3-axis-x-label';
+CLASS[_axisY] = 'c3-axis-y';
+CLASS[_axisYLabel] = 'c3-axis-y-label';
+CLASS[_axisY2] = 'c3-axis-y2';
+CLASS[_axisY2Label] = 'c3-axis-y2-label';
+CLASS[_legendBackground] = 'c3-legend-background';
+CLASS[_legendItem] = 'c3-legend-item';
+CLASS[_legendItemEvent] = 'c3-legend-item-event';
+CLASS[_legendItemTile] = 'c3-legend-item-tile';
+CLASS[_legendItemHidden] = 'c3-legend-item-hidden';
+CLASS[_legendItemFocused] = 'c3-legend-item-focused';
+CLASS[_dragarea] = 'c3-dragarea';
+CLASS[_EXPANDED] = '_expanded_';
+CLASS[_SELECTED] = '_selected_';
+CLASS[_INCLUDED] = '_included_';
+
+c3_chart_internal_fn.generateClass = function (prefix, targetId) {
+    return " " + prefix + " " + prefix + this.getTargetSelectorSuffix(targetId);
+};
+c3_chart_internal_fn.classText = function (d) {
+    return this.generateClass(CLASS[_text], d.index);
+};
+c3_chart_internal_fn.classTexts = function (d) {
+    return this.generateClass(CLASS[_texts], d.id);
+};
+c3_chart_internal_fn.classShape = function (d) {
+    return this.generateClass(CLASS[_shape], d.index);
+};
+c3_chart_internal_fn.classShapes = function (d) {
+    return this.generateClass(CLASS[_shapes], d.id);
+};
+c3_chart_internal_fn.classLine = function (d) {
+    return this.classShape(d) + this.generateClass(CLASS[_line], d.id);
+};
+c3_chart_internal_fn.classLines = function (d) {
+    return this.classShapes(d) + this.generateClass(CLASS[_lines], d.id);
+};
+c3_chart_internal_fn.classCircle = function (d) {
+    return this.classShape(d) + this.generateClass(CLASS[_circle], d.index);
+};
+c3_chart_internal_fn.classCircles = function (d) {
+    return this.classShapes(d) + this.generateClass(CLASS[_circles], d.id);
+};
+c3_chart_internal_fn.classBar = function (d) {
+    return this.classShape(d) + this.generateClass(CLASS[_bar], d.index);
+};
+c3_chart_internal_fn.classBars = function (d) {
+    return this.classShapes(d) + this.generateClass(CLASS[_bars], d.id);
+};
+c3_chart_internal_fn.classArc = function (d) {
+    return this.classShape(d.data) + this.generateClass(CLASS[_arc], d.data.id);
+};
+c3_chart_internal_fn.classArcs = function (d) {
+    return this.classShapes(d.data) + this.generateClass(CLASS[_arcs], d.data.id);
+};
+c3_chart_internal_fn.classArea = function (d) {
+    return this.classShape(d) + this.generateClass(CLASS[_area], d.id);
+};
+c3_chart_internal_fn.classAreas = function (d) {
+    return this.classShapes(d) + this.generateClass(CLASS[_areas], d.id);
+};
+c3_chart_internal_fn.classRegion = function (d, i) {
+    return this.generateClass(CLASS[_region], i) + ' ' + ('class' in d ? d.class : '');
+};
+c3_chart_internal_fn.classEvent = function (d) {
+    return this.generateClass(CLASS[_eventRect], d.index);
+};
+c3_chart_internal_fn.classTarget = function (id) {
+    var $$ = this;
+    var additionalClassSuffix = $$.config[__data_classes][id], additionalClass = '';
+    if (additionalClassSuffix) {
+        additionalClass = ' ' + CLASS[_target] + '-' + additionalClassSuffix;
+    }
+    return $$.generateClass(CLASS[_target], id) + additionalClass;
+};
+c3_chart_internal_fn.classChartText = function (d) {
+    return CLASS[_chartText] + this.classTarget(d.id);
+};
+c3_chart_internal_fn.classChartLine = function (d) {
+    return CLASS[_chartLine] + this.classTarget(d.id);
+};
+c3_chart_internal_fn.classChartBar = function (d) {
+    return CLASS[_chartBar] + this.classTarget(d.id);
+};
+c3_chart_internal_fn.classChartArc = function (d) {
+    return CLASS[_chartArc] + this.classTarget(d.data.id);
+};
+c3_chart_internal_fn.getTargetSelectorSuffix = function (targetId) {
+    return targetId || targetId === 0 ? '-' + (targetId.replace ? targetId.replace(/([^a-zA-Z0-9-_])/g, '-') : targetId) : '';
+};
+c3_chart_internal_fn.selectorTarget = function (id) {
+    return '.' + CLASS[_target] + this.getTargetSelectorSuffix(id);
+};
+c3_chart_internal_fn.selectorTargets = function (ids) {
+    var $$ = this;
+    return ids.length ? ids.map(function (id) { return $$.selectorTarget(id); }) : null;
+};
+c3_chart_internal_fn.selectorLegend = function (id) {
+    return '.' + CLASS[_legendItem] + this.getTargetSelectorSuffix(id);
+};
+c3_chart_internal_fn.selectorLegends = function (ids) {
+    var $$ = this;
+    return ids.length ? ids.map(function (id) { return $$.selectorLegend(id); }) : null;
+};

src/clip.js

+c3_chart_internal_fn.getClipPath = function (id) {
+    var isIE9 = window.navigator.appVersion.toLowerCase().indexOf("msie 9.") >= 0;
+    return "url(" + (isIE9 ? "" : document.URL.split('#')[0]) + "#" + id + ")";
+};
+c3_chart_internal_fn.getAxisClipX = function (forHorizontal) {
+    // axis line width + padding for left
+    return forHorizontal ? -(1 + 30) : -(this.margin.left - 1);
+};
+c3_chart_internal_fn.getAxisClipY = function (forHorizontal) {
+    return forHorizontal ? -20 : -4;
+};
+c3_chart_internal_fn.getXAxisClipX = function () {
+    var $$ = this;
+    return $$.getAxisClipX(!$$.config[__axis_rotated]);
+};
+c3_chart_internal_fn.getXAxisClipY = function () {
+    var $$ = this;
+    return $$.getAxisClipY(!$$.config[__axis_rotated]);
+};
+c3_chart_internal_fn.getYAxisClipX = function () {
+    var $$ = this;
+    return $$.getAxisClipX($$.config[__axis_rotated]);
+};
+c3_chart_internal_fn.getYAxisClipY = function () {
+    var $$ = this;
+    return $$.getAxisClipY($$.config[__axis_rotated]);
+};
+c3_chart_internal_fn.getAxisClipWidth = function (forHorizontal) {
+    var $$ = this;
+    // width + axis line width + padding for left/right
+    return forHorizontal ? $$.width + 2 + 30 + 30 : $$.margin.left + 20;
+};
+c3_chart_internal_fn.getAxisClipHeight = function (forHorizontal) {
+    var $$ = this, config = $$.config;
+    return forHorizontal ? (config[__axis_x_height] ? config[__axis_x_height] : 0) + 80 : $$.height + 8;
+};
+c3_chart_internal_fn.getXAxisClipWidth = function () {
+    var $$ = this;
+    return $$.getAxisClipWidth(!$$.config[__axis_rotated]);
+};
+c3_chart_internal_fn.getXAxisClipHeight = function () {
+    var $$ = this;
+    return $$.getAxisClipHeight(!$$.config[__axis_rotated]);
+};
+c3_chart_internal_fn.getYAxisClipWidth = function () {
+    var $$ = this;
+    return $$.getAxisClipWidth($$.config[__axis_rotated]);
+};
+c3_chart_internal_fn.getYAxisClipHeight = function () {
+    var $$ = this;
+    return $$.getAxisClipHeight($$.config[__axis_rotated]);
+};

src/color.js

+c3_chart_internal_fn.generateColor = function () {
+    var $$ = this, config = $$.config, d3 = $$.d3,
+        colors = config[__data_colors],
+        pattern = notEmpty(config[__color_pattern]) ? config[__color_pattern] : d3.scale.category10().range(),
+        callback = config[__data_color],
+        ids = [];
+
+    return function (d) {
+        var id = d.id || d, color;
+
+        // if callback function is provided
+        if (colors[id] instanceof Function) {
+            color = colors[id](d);
+        }
+        // if specified, choose that color
+        else if (colors[id]) {
+            color = colors[id];
+        }
+        // if not specified, choose from pattern
+        else {
+            if (ids.indexOf(id) < 0) { ids.push(id); }
+            color = pattern[ids.indexOf(id) % pattern.length];
+            colors[id] = color;
+        }
+        return callback instanceof Function ? callback(color, d) : color;
+    };
+};
+c3_chart_internal_fn.generateLevelColor = function () {
+    var $$ = this, config = $$.config,
+        colors = config[__color_pattern],
+        threshold = config[__color_threshold],
+        asValue = threshold.unit === 'value',
+        values = threshold.values && threshold.values.length ? threshold.values : [],
+        max = threshold.max || 100;
+    return notEmpty(config[__color_threshold]) ? function (value) {
+        var i, v, color = colors[colors.length - 1];
+        for (i = 0; i < values.length; i++) {
+            v = asValue ? value : (value * 100 / max);
+            if (v < values[i]) {
+                color = colors[i];
+                break;
+            }
+        }
+        return color;
+    } : null;
+};

src/data.convert.js

+c3_chart_internal_fn.convertUrlToData = function (url, mimeType, keys, done) {
+    var $$ = this, type = mimeType ? mimeType : 'csv';
+    $$.d3.xhr(url, function (error, data) {
+        var d;
+        if (type === 'json') {
+            d = $$.convertJsonToData(JSON.parse(data.response), keys);
+        } else {
+            d = $$.convertCsvToData(data.response);
+        }
+        done(d);
+    });
+};
+c3_chart_internal_fn.convertCsvToData = function (csv) {
+    var d3 = this.d3, rows = d3.csv.parseRows(csv), d;
+    if (rows.length === 1) {
+        d = [{}];
+        rows[0].forEach(function (id) {
+            d[0][id] = null;
+        });
+    } else {
+        d = d3.csv.parse(csv);
+    }
+    return d;
+};
+c3_chart_internal_fn.convertJsonToData = function (json, keys) {
+    var $$ = this,
+        new_rows = [], targetKeys, data;
+    if (keys) { // when keys specified, json would be an array that includes objects
+        targetKeys = keys.value;
+        if (keys.x) {
+            targetKeys.push(keys.x);
+            $$.config[__data_x] = keys.x;
+        }
+        new_rows.push(targetKeys);
+        json.forEach(function (o) {
+            var new_row = [];
+            targetKeys.forEach(function (key) {
+                // convert undefined to null because undefined data will be removed in convertDataToTargets()
+                var v = isUndefined(o[key]) ? null : o[key];
+                new_row.push(v);
+            });
+            new_rows.push(new_row);
+        });
+        data = $$.convertRowsToData(new_rows);
+    } else {
+        Object.keys(json).forEach(function (key) {
+            new_rows.push([key].concat(json[key]));
+        });
+        data = $$.convertColumnsToData(new_rows);
+    }
+    return data;
+};
+c3_chart_internal_fn.convertRowsToData = function (rows) {
+    var keys = rows[0], new_row = {}, new_rows = [], i, j;
+    for (i = 1; i < rows.length; i++) {
+        new_row = {};
+        for (j = 0; j < rows[i].length; j++) {
+            if (isUndefined(rows[i][j])) {
+                throw new Error("Source data is missing a component at (" + i + "," + j + ")!");
+            }
+            new_row[keys[j]] = rows[i][j];
+        }
+        new_rows.push(new_row);
+    }
+    return new_rows;
+};
+c3_chart_internal_fn.convertColumnsToData = function (columns) {
+    var new_rows = [], i, j, key;
+    for (i = 0; i < columns.length; i++) {
+        key = columns[i][0];
+        for (j = 1; j < columns[i].length; j++) {
+            if (isUndefined(new_rows[j - 1])) {
+                new_rows[j - 1] = {};
+            }
+            if (isUndefined(columns[i][j])) {
+                throw new Error("Source data is missing a component at (" + i + "," + j + ")!");
+            }
+            new_rows[j - 1][key] = columns[i][j];
+        }
+    }
+    return new_rows;
+};
+c3_chart_internal_fn.convertDataToTargets = function (data, appendXs) {
+    var $$ = this, config = $$.config,
+        ids = $$.d3.keys(data[0]).filter($$.isNotX, $$),
+        xs = $$.d3.keys(data[0]).filter($$.isX, $$),
+        targets;
+
+    // save x for update data by load when custom x and c3.x API
+    ids.forEach(function (id) {
+        var xKey = $$.getXKey(id);
+
+        if ($$.isCustomX() || $$.isTimeSeries()) {
+            // if included in input data
+            if (xs.indexOf(xKey) >= 0) {
+                $$.data.xs[id] = (appendXs && $$.data.xs[id] ? $$.data.xs[id] : []).concat(
+                    data.map(function (d) { return d[xKey]; })
+                        .filter(isValue)
+                        .map(function (rawX, i) { return $$.generateTargetX(rawX, id, i); })
+                );
+            }
+            // if not included in input data, find from preloaded data of other id's x
+            else if (config[__data_x]) {
+                $$.data.xs[id] = $$.getOtherTargetXs();
+            }
+            // if not included in input data, find from preloaded data
+            else if (notEmpty(config[__data_xs])) {
+                $$.data.xs[id] = $$.getXValuesOfXKey(xKey, $$.data.targets);
+            }
+            // MEMO: if no x included, use same x of current will be used
+        } else {
+            $$.data.xs[id] = data.map(function (d, i) { return i; });
+        }
+    });
+
+    // check x is defined
+    ids.forEach(function (id) {
+        if (!$$.data.xs[id]) {
+            throw new Error('x is not defined for id = "' + id + '".');
+        }
+    });
+
+    // convert to target
+    targets = ids.map(function (id, index) {
+        var convertedId = config[__data_id_converter](id);
+        return {
+            id: convertedId,
+            id_org: id,
+            values: data.map(function (d, i) {
+                var xKey = $$.getXKey(id), rawX = d[xKey], x = $$.generateTargetX(rawX, id, i);
+                // use x as categories if custom x and categorized
+                if ($$.isCustomX() && $$.isCategorized() && index === 0 && rawX) {
+                    if (i === 0) { config[__axis_x_categories] = []; }
+                    config[__axis_x_categories].push(rawX);
+                }
+                // mark as x = undefined if value is undefined and filter to remove after mapped
+                if (isUndefined(d[id]) || $$.data.xs[id].length <= i) {
+                    x = undefined;
+                }
+                return {x: x, value: d[id] !== null && !isNaN(d[id]) ? +d[id] : null, id: convertedId};
+            }).filter(function (v) { return isDefined(v.x); })
+        };
+    });
+
+    // finish targets
+    targets.forEach(function (t) {
+        var i;
+        // sort values by its x
+        t.values = t.values.sort(function (v1, v2) {
+            var x1 = v1.x || v1.x === 0 ? v1.x : Infinity,
+                x2 = v2.x || v2.x === 0 ? v2.x : Infinity;
+            return x1 - x2;
+        });
+        // indexing each value
+        i = 0;
+        t.values.forEach(function (v) {
+            v.index = i++;
+        });
+        // this needs to be sorted because its index and value.index is identical
+        $$.data.xs[t.id].sort(function (v1, v2) {
+            return v1 - v2;
+        });
+    });
+
+    // set target types
+    if (config[__data_type]) {
+        $$.setTargetType($$.mapToIds(targets).filter(function (id) { return ! (id in config[__data_types]); }), config[__data_type]);
+    }
+
+    // cache as original id keyed
+    targets.forEach(function (d) {
+        $$.addCache(d.id_org, d);
+    });
+
+    return targets;
+};

src/data.load.js

+c3_chart_internal_fn.load = function (targets, args) {
+    var $$ = this;
+    if (targets) {
+        // filter loading targets if needed
+        if (args.filter) {
+            targets = targets.filter(args.filter);
+        }
+        // set type if args.types || args.type specified
+        if (args.type || args.types) {
+            targets.forEach(function (t) {
+                $$.setTargetType(t.id, args.types ? args.types[t.id] : args.type);
+            });
+        }
+        // Update/Add data
+        $$.data.targets.forEach(function (d) {
+            for (var i = 0; i < targets.length; i++) {
+                if (d.id === targets[i].id) {
+                    d.values = targets[i].values;
+                    targets.splice(i, 1);
+                    break;
+                }
+            }
+        });
+        $$.data.targets = $$.data.targets.concat(targets); // add remained
+    }
+
+    // Set targets
+    $$.updateTargets($$.data.targets);
+
+    // Redraw with new targets
+    $$.redraw({withUpdateOrgXDomain: true, withUpdateXDomain: true, withLegend: true});
+
+    if (isFunction(args.done)) {
+        args.done();
+    }
+};
+c3_chart_internal_fn.loadFromArgs = function (args) {
+    var $$ = this;
+    if (args.data) {
+        $$.load($$.convertDataToTargets(args.data), args);
+    }
+    else if (args.url) {
+        $$.convertUrlToData(args.url, args.mimeType, args.keys, function (data) {
+            $$.load($$.convertDataToTargets(data), args);
+        });
+    }
+    else if (args.json) {
+        $$.load($$.convertDataToTargets($$.convertJsonToData(args.json, args.keys)), args);
+    }
+    else if (args.rows) {
+        $$.load($$.convertDataToTargets($$.convertRowsToData(args.rows)), args);
+    }
+    else if (args.columns) {
+        $$.load($$.convertDataToTargets($$.convertColumnsToData(args.columns)), args);
+    }
+    else {
+        $$.load(null, args);
+    }
+};
+c3_chart_internal_fn.unload = function (targetIds, done) {
+    var $$ = this;
+    if (!isFunction(done)) {
+        done = function () {};
+    }
+    // filter existing target
+    targetIds = targetIds.filter(function (id) { return $$.hasTarget($$.data.targets, id); });
+    // If no target, call done and return
+    if (!targetIds || targetIds.length === 0) {
+        done();
+        return;
+    }
+    $$.svg.selectAll(targetIds.map(function (id) { return $$.selectorTarget(id); }))
+        .transition()
+        .style('opacity', 0)
+        .remove()
+        .call($$.endall, done);
+    targetIds.forEach(function (id) {
+        // Reset fadein for future load
+        $$.withoutFadeIn[id] = false;
+        // Remove target's elements
+        if ($$.legend) {
+            $$.legend.selectAll('.' + CLASS[_legendItem] + $$.getTargetSelectorSuffix(id)).remove();
+        }
+        // Remove target
+        $$.data.targets = $$.data.targets.filter(function (t) {
+            return t.id !== id;
+        });
+    });
+};

src/domain.js

+c3_chart_internal_fn.getYDomainMin = function (targets) {
+    var $$ = this, config = $$.config,
+        ids = $$.mapToIds(targets), ys = $$.getValuesAsIdKeyed(targets),
+        j, k, baseId, idsInGroup, id, hasNegativeValue;
+    if (config[__data_groups].length > 0) {
+        hasNegativeValue = $$.hasNegativeValueInTargets(targets);
+        for (j = 0; j < config[__data_groups].length; j++) {
+            // Determine baseId
+            idsInGroup = config[__data_groups][j].filter(function (id) { return ids.indexOf(id) >= 0; });
+            if (idsInGroup.length === 0) { continue; }
+            baseId = idsInGroup[0];
+            // Consider negative values
+            if (hasNegativeValue && ys[baseId]) {
+                ys[baseId].forEach(function (v, i) {
+                    ys[baseId][i] = v < 0 ? v : 0;
+                });
+            }
+            // Compute min
+            for (k = 1; k < idsInGroup.length; k++) {
+                id = idsInGroup[k];
+                if (! ys[id]) { continue; }
+                ys[id].forEach(function (v, i) {
+                    if ($$.getAxisId(id) === $$.getAxisId(baseId) && ys[baseId] && !(hasNegativeValue && +v > 0)) {
+                        ys[baseId][i] += +v;
+                    }
+                });
+            }
+        }
+    }
+    return $$.d3.min(Object.keys(ys).map(function (key) { return $$.d3.min(ys[key]); }));
+};
+c3_chart_internal_fn.getYDomainMax = function (targets) {
+    var $$ = this, config = $$.config,
+        ids = $$.mapToIds(targets), ys = $$.getValuesAsIdKeyed(targets),
+        j, k, baseId, idsInGroup, id, hasPositiveValue;
+    if (config[__data_groups].length > 0) {
+        hasPositiveValue = $$.hasPositiveValueInTargets(targets);
+        for (j = 0; j < config[__data_groups].length; j++) {
+            // Determine baseId
+            idsInGroup = config[__data_groups][j].filter(function (id) { return ids.indexOf(id) >= 0; });
+            if (idsInGroup.length === 0) { continue; }
+            baseId = idsInGroup[0];
+            // Consider positive values
+            if (hasPositiveValue && ys[baseId]) {
+                ys[baseId].forEach(function (v, i) {
+                    ys[baseId][i] = v > 0 ? v : 0;
+                });
+            }
+            // Compute max
+            for (k = 1; k < idsInGroup.length; k++) {
+                id = idsInGroup[k];
+                if (! ys[id]) { continue; }
+                ys[id].forEach(function (v, i) {
+                    if ($$.getAxisId(id) === $$.getAxisId(baseId) && ys[baseId] && !(hasPositiveValue && +v < 0)) {
+                        ys[baseId][i] += +v;
+                    }
+                });
+            }
+        }
+    }
+    return $$.d3.max(Object.keys(ys).map(function (key) { return $$.d3.max(ys[key]); }));
+};
+c3_chart_internal_fn.getYDomain = function (targets, axisId) {
+    var $$ = this, config = $$.config,
+        yTargets = targets.filter(function (d) { return $$.getAxisId(d.id) === axisId; }),
+        yMin = axisId === 'y2' ? config[__axis_y2_min] : config[__axis_y_min],
+        yMax = axisId === 'y2' ? config[__axis_y2_max] : config[__axis_y_max],
+        yDomainMin = isValue(yMin) ? yMin : $$.getYDomainMin(yTargets),
+        yDomainMax = isValue(yMax) ? yMax : $$.getYDomainMax(yTargets),
+        domainLength, padding, padding_top, padding_bottom,
+        center = axisId === 'y2' ? config[__axis_y2_center] : config[__axis_y_center],
+        yDomainAbs, lengths, diff, ratio, isAllPositive, isAllNegative,
+        isZeroBased = ($$.hasType('bar', yTargets) && config[__bar_zerobased]) || ($$.hasType('area', yTargets) && config[__area_zerobased]),
+        showHorizontalDataLabel = $$.hasDataLabel() && config[__axis_rotated],
+        showVerticalDataLabel = $$.hasDataLabel() && !config[__axis_rotated];
+    if (yTargets.length === 0) { // use current domain if target of axisId is none
+        return axisId === 'y2' ? $$.y2.domain() : $$.y.domain();
+    }
+    if (yDomainMin === yDomainMax) {
+        yDomainMin < 0 ? yDomainMax = 0 : yDomainMin = 0;
+    }
+    isAllPositive = yDomainMin >= 0 && yDomainMax >= 0;
+    isAllNegative = yDomainMin <= 0 && yDomainMax <= 0;
+
+    // Bar/Area chart should be 0-based if all positive|negative
+    if (isZeroBased) {
+        if (isAllPositive) { yDomainMin = 0; }
+        if (isAllNegative) { yDomainMax = 0; }
+    }
+
+    domainLength = Math.abs(yDomainMax - yDomainMin);
+    padding = padding_top = padding_bottom = domainLength * 0.1;
+
+    if (center) {
+        yDomainAbs = Math.max(Math.abs(yDomainMin), Math.abs(yDomainMax));
+        yDomainMax = yDomainAbs - center;
+        yDomainMin = center - yDomainAbs;
+    }
+    // add padding for data label
+    if (showHorizontalDataLabel) {
+        lengths = $$.getDataLabelLength(yDomainMin, yDomainMax, axisId, 'width');
+        diff = diffDomain($$.y.range());
+        ratio = [lengths[0] / diff, lengths[1] / diff];
+        padding_top += domainLength * (ratio[1] / (1 - ratio[0] - ratio[1]));
+        padding_bottom += domainLength * (ratio[0] / (1 - ratio[0] - ratio[1]));
+    } else if (showVerticalDataLabel) {
+        lengths = $$.getDataLabelLength(yDomainMin, yDomainMax, axisId, 'height');
+        padding_top += lengths[1];
+        padding_bottom += lengths[0];
+    }
+    if (axisId === 'y' && config[__axis_y_padding]) {
+        padding_top = $$.getAxisPadding(config[__axis_y_padding], 'top', padding, domainLength);
+        padding_bottom = $$.getAxisPadding(config[__axis_y_padding], 'bottom', padding, domainLength);
+    }
+    if (axisId === 'y2' && config[__axis_y2_padding]) {
+        padding_top = $$.getAxisPadding(config[__axis_y2_padding], 'top', padding, domainLength);
+        padding_bottom = $$.getAxisPadding(config[__axis_y2_padding], 'bottom', padding, domainLength);
+    }
+    // Bar/Area chart should be 0-based if all positive|negative
+    if (isZeroBased) {
+        if (isAllPositive) { padding_bottom = yDomainMin; }
+        if (isAllNegative) { padding_top = -yDomainMax; }
+    }
+    return [yDomainMin - padding_bottom, yDomainMax + padding_top];
+};
+c3_chart_internal_fn.getXDomainMin = function (targets) {
+    var $$ = this, config = $$.config;
+    return config[__axis_x_min] ?
+        ($$.isTimeSeries() ? this.parseDate(config[__axis_x_min]) : config[__axis_x_min]) :
+    $$.d3.min(targets, function (t) { return $$.d3.min(t.values, function (v) { return v.x; }); });
+};
+c3_chart_internal_fn.getXDomainMax = function (targets) {
+    var $$ = this, config = $$.config;
+    return config[__axis_x_max] ?
+        ($$.isTimeSeries() ? this.parseDate(config[__axis_x_max]) : config[__axis_x_max]) :
+    $$.d3.max(targets, function (t) { return $$.d3.max(t.values, function (v) { return v.x; }); });
+};
+c3_chart_internal_fn.getXDomainPadding = function (targets) {
+    var $$ = this, config = $$.config,
+        edgeX = this.getEdgeX(targets), diff = edgeX[1] - edgeX[0],
+        maxDataCount, padding, paddingLeft, paddingRight;
+    if ($$.isCategorized()) {
+        padding = 0;
+    } else if ($$.hasType('bar', targets)) {
+        maxDataCount = $$.getMaxDataCount();
+        padding = maxDataCount > 1 ? (diff / (maxDataCount - 1)) / 2 : 0.5;
+    } else {
+        padding = diff * 0.01;
+    }
+    if (typeof config[__axis_x_padding] === 'object' && notEmpty(config[__axis_x_padding])) {
+        paddingLeft = isValue(config[__axis_x_padding].left) ? config[__axis_x_padding].left : padding;
+        paddingRight = isValue(config[__axis_x_padding].right) ? config[__axis_x_padding].right : padding;
+    } else if (typeof config[__axis_x_padding] === 'number') {
+        paddingLeft = paddingRight = config[__axis_x_padding];
+    } else {
+        paddingLeft = paddingRight = padding;
+    }
+    return {left: paddingLeft, right: paddingRight};
+};
+c3_chart_internal_fn.getXDomain = function (targets) {
+    var $$ = this,
+        xDomain = [$$.getXDomainMin(targets), $$.getXDomainMax(targets)],
+        firstX = xDomain[0], lastX = xDomain[1],
+        padding = $$.getXDomainPadding(targets),
+        min = 0, max = 0;
+    // show center of x domain if min and max are the same
+    if ((firstX - lastX) === 0 && !$$.isCategorized()) {
+        firstX = $$.isTimeSeries() ? new Date(firstX.getTime() * 0.5) : -0.5;
+        lastX = $$.isTimeSeries() ? new Date(lastX.getTime() * 1.5) : 0.5;
+    }
+    if (firstX || firstX === 0) {
+        min = $$.isTimeSeries() ? new Date(firstX.getTime() - padding.left) : firstX - padding.left;
+    }
+    if (lastX || lastX === 0) {
+        max = $$.isTimeSeries() ? new Date(lastX.getTime() + padding.right) : lastX + padding.right;
+    }
+    return [min, max];
+};
+c3_chart_internal_fn.updateXDomain = function (targets, withUpdateXDomain, withUpdateOrgXDomain, domain) {
+    var $$ = this, config = $$.config;
+    if (withUpdateOrgXDomain) {
+        $$.x.domain(domain ? domain : $$.d3.extent($$.getXDomain(targets)));
+        $$.orgXDomain = $$.x.domain();
+        if (config[__zoom_enabled]) { $$.zoom.scale($$.x).updateScaleExtent(); }
+        $$.subX.domain($$.x.domain());
+        if ($$.brush) { $$.brush.scale($$.subX); }
+    }
+    if (withUpdateXDomain) {
+        $$.x.domain(domain ? domain : (!$$.brush || $$.brush.empty()) ? $$.orgXDomain : $$.brush.extent());
+        if (config[__zoom_enabled]) { $$.zoom.scale($$.x).updateScaleExtent(); }
+    }
+    return $$.x.domain();
+};

src/drag.js

+c3_chart_internal_fn.drag = function (mouse) {
+    var $$ = this, config = $$.config, main = $$.main, d3 = $$.d3;
+    var sx, sy, mx, my, minX, maxX, minY, maxY;
+
+    if ($$.hasArcType()) { return; }
+    if (! config[__data_selection_enabled]) { return; } // do nothing if not selectable
+    if (config[__zoom_enabled] && ! $$.zoom.altDomain) { return; } // skip if zoomable because of conflict drag dehavior
+    if (!config[__data_selection_multiple]) { return; } // skip when single selection because drag is used for multiple selection
+
+    sx = $$.dragStart[0];
+    sy = $$.dragStart[1];
+    mx = mouse[0];
+    my = mouse[1];
+    minX = Math.min(sx, mx);
+    maxX = Math.max(sx, mx);
+    minY = (config[__data_selection_grouped]) ? $$.margin.top : Math.min(sy, my);
+    maxY = (config[__data_selection_grouped]) ? $$.height : Math.max(sy, my);
+
+    main.select('.' + CLASS[_dragarea])
+        .attr('x', minX)
+        .attr('y', minY)
+        .attr('width', maxX - minX)
+        .attr('height', maxY - minY);
+    // TODO: binary search when multiple xs
+    main.selectAll('.' + CLASS[_shapes]).selectAll('.' + CLASS[_shape])
+        .filter(function (d) { return config[__data_selection_isselectable](d); })
+        .each(function (d, i) {
+            var shape = d3.select(this),
+                isSelected = shape.classed(CLASS[_SELECTED]),
+                isIncluded = shape.classed(CLASS[_INCLUDED]),
+                _x, _y, _w, _h, toggle, isWithin = false, box;
+            if (shape.classed(CLASS[_circle])) {
+                _x = shape.attr("cx") * 1;
+                _y = shape.attr("cy") * 1;
+                toggle = $$.togglePoint;
+                isWithin = minX < _x && _x < maxX && minY < _y && _y < maxY;
+            }
+            else if (shape.classed(CLASS[_bar])) {
+                box = getPathBox(this);
+                _x = box.x;
+                _y = box.y;
+                _w = box.width;
+                _h = box.height;
+                toggle = $$.toggleBar;
+                isWithin = !(maxX < _x || _x + _w < minX) && !(maxY < _y || _y + _h < minY);
+            } else {
+                // line/area selection not supported yet
+                return;
+            }
+            if (isWithin ^ isIncluded) {
+                shape.classed(CLASS[_INCLUDED], !isIncluded);
+                // TODO: included/unincluded callback here
+                shape.classed(CLASS[_SELECTED], !isSelected);
+                $$.toggle(!isSelected, shape, d, i);
+            }
+        });
+};
+
+c3_chart_internal_fn.dragstart = function (mouse) {
+    var $$ = this, config = $$.config;
+    if ($$.hasArcType()) { return; }
+    if (! config[__data_selection_enabled]) { return; } // do nothing if not selectable
+    $$.dragStart = mouse;
+    $$.main.select('.' + CLASS[_chart]).append('rect')
+        .attr('class', CLASS[_dragarea])
+        .style('opacity', 0.1);
+    $$.dragging = true;
+    $$.config[__data_ondragstart]();
+};
+
+c3_chart_internal_fn.dragend = function () {
+    var $$ = this, config = $$.config;
+    if ($$.hasArcType()) { return; }
+    if (! config[__data_selection_enabled]) { return; } // do nothing if not selectable
+    $$.main.select('.' + CLASS[_dragarea])
+        .transition().duration(100)
+        .style('opacity', 0)
+        .remove();
+    $$.main.selectAll('.' + CLASS[_shape])
+        .classed(CLASS[_INCLUDED], false);
+    $$.dragging = false;
+    $$.config[__data_ondragend]();
+};
+

src/format.js

+c3_chart_internal_fn.getYFormat = function (forArc) {
+    var $$ = this,
+        formatForY = forArc && !$$.hasType('gauge') ? $$.defaultArcValueFormat : $$.yFormat,
+        formatForY2 = forArc && !$$.hasType('gauge') ? $$.defaultArcValueFormat : $$.y2Format;
+    return function (v, ratio, id) {
+        var format = $$.getAxisId(id) === 'y2' ? formatForY2 : formatForY;
+        return format.call($$, v, ratio);
+    };
+};
+c3_chart_internal_fn.yFormat = function (v) {
+    var $$ = this, config = $$.config,
+        format = config[__axis_y_tick_format] ? config[__axis_y_tick_format] : $$.defaultValueFormat;
+    return format(v);
+};
+c3_chart_internal_fn.y2Format = function (v) {
+    var $$ = this, config = $$.config,
+        format = config[__axis_y2_tick_format] ? config[__axis_y2_tick_format] : $$.defaultValueFormat;
+    return format(v);
+};
+c3_chart_internal_fn.defaultValueFormat = function (v) {
+    return isValue(v) ? +v : "";
+};
+c3_chart_internal_fn.defaultArcValueFormat = function (v, ratio) {
+    return (ratio * 100).toFixed(1) + '%';
+};
+c3_chart_internal_fn.formatByAxisId = function (axisId) {
+    var $$ = this.internal, data_labels = $$.config[__data_labels],
+        format = function (v) { return isValue(v) ? +v : ""; };
+    // find format according to axis id
+    if (isFunction(data_labels.format)) {
+        format = data_labels.format;
+    } else if (typeof data_labels.format === 'object') {
+        if (isFunction(data_labels.format[axisId])) {
+            format = data_labels.format[axisId];
+        }
+    }
+    return format;
+};

src/grid.js

+c3_chart_internal_fn.showXGridFocus = function (selectedData) {
+    var $$ = this, dataToShow = selectedData.filter(function (d) { return d && isValue(d.value); });
+    if (! config[__tooltip_show]) { return; }
+    // Hide when scatter plot exists
+    if ($$.hasType('scatter') || $$.hasArcType()) { return; }
+    var focusEl = $$.main.selectAll('line.' + CLASS[_xgridFocus]);
+    focusEl
+        .style("visibility", "visible")
+        .data([dataToShow[0]])
+        .attr(config[__axis_rotated] ? 'y1' : 'x1', generateCall($$.xx, $$))
+        .attr(config[__axis_rotated] ? 'y2' : 'x2', generateCall($$.xx, $$));
+    $$.smoothLines(focusEl, 'grid');
+};
+c3_chart_internal_fn.hideXGridFocus = function () {
+    this.main.select('line.' + CLASS[_xgridFocus]).style("visibility", "hidden");
+};
+c3_chart_internal_fn.updateXgridFocus = function () {
+    var $$ = this, config = $$.config;
+    $$.main.select('line.' + CLASS[_xgridFocus])
+        .attr("x1", config[__axis_rotated] ? 0 : -10)
+        .attr("x2", config[__axis_rotated] ? $$.width : -10)
+        .attr("y1", config[__axis_rotated] ? -10 : 0)
+        .attr("y2", config[__axis_rotated] ? -10 : $$.height);
+};
+c3_chart_internal_fn.generateGridData = function (type, scale) {
+    var $$ = this,
+        gridData = [], xDomain, firstYear, lastYear, i,
+        tickNum = $$.main.select("." + CLASS[_axisX]).selectAll('.tick').size();
+    if (type === 'year') {
+        xDomain = $$.getXDomain();
+        firstYear = xDomain[0].getFullYear();
+        lastYear = xDomain[1].getFullYear();
+        for (i = firstYear; i <= lastYear; i++) {
+            gridData.push(new Date(i + '-01-01 00:00:00'));
+        }
+    } else {
+        gridData = scale.ticks(10);
+        if (gridData.length > tickNum) { // use only int
+            gridData = gridData.filter(function (d) { return ("" + d).indexOf('.') < 0; });
+        }
+    }
+    return gridData;
+};
+c3_chart_internal_fn.getGridFilterToRemove = function (params) {
+    return params ? function (line) {
+        var found = false;
+        [].concat(params).forEach(function (param) {
+            if ((('value' in param && line.value === params.value) || ('class' in param && line.class === params.class))) {
+                found = true;
+            }
+        });
+        return found;
+    } : function () { return true; };
+};
+c3_chart_internal_fn.removeGridLines = function (params, forX) {
+    var $$ = this, config = $$.config,
+        toRemove = $$.getGridFilterToRemove(params),
+        toShow = function (line) { return !toRemove(line); },
+        classLines = forX ? CLASS[_xgridLines] : CLASS[_ygridLines],
+        classLine = forX ? CLASS[_xgridLine] : CLASS.ygridLine;
+    $$.main.select('.' + classLines).selectAll('.' + classLine).filter(toRemove)
+        .transition().duration(config[__transition_duration])
+        .style('opacity', 0).remove();
+    if (forX) {
+        config[__grid_x_lines] = config[__grid_x_lines].filter(toShow);
+    } else {
+        config[__grid_y_lines] = config[__grid_y_lines].filter(toShow);
+    }
+};

src/head.js

+(function (window) {
+    'use strict';
+
+    /*global define, module, exports, require */

src/region.js

+c3_chart_internal_fn.regionX = function (d) {
+    var $$ = this, config = $$.config,
+        xPos, yScale = d.axis === 'y' ? $$.y : $$.y2;
+    if (d.axis === 'y' || d.axis === 'y2') {
+        xPos = config[__axis_rotated] ? ('start' in d ? yScale(d.start) : 0) : 0;
+    } else {
+        xPos = config[__axis_rotated] ? 0 : ('start' in d ? $$.x($$.isTimeSeries() ? $$.parseDate(d.start) : d.start) : 0);
+    }
+    return xPos;
+};
+c3_chart_internal_fn.regionY = function (d) {
+    var $$ = this, config = $$.config,
+        yPos, yScale = d.axis === 'y' ? $$.y : $$.y2;
+    if (d.axis === 'y' || d.axis === 'y2') {
+        yPos = config[__axis_rotated] ? 0 : ('end' in d ? yScale(d.end) : 0);
+    } else {
+        yPos = config[__axis_rotated] ? ('start' in d ? $$.x($$.isTimeSeries() ? $$.parseDate(d.start) : d.start) : 0) : 0;
+    }
+    return yPos;
+};
+c3_chart_internal_fn.regionWidth = function (d) {
+    var $$ = this, config = $$.config,
+        start = $$.regionX(d), end, yScale = d.axis === 'y' ? $$.y : $$.y2;
+    if (d.axis === 'y' || d.axis === 'y2') {
+        end = config[__axis_rotated] ? ('end' in d ? yScale(d.end) : $$.width) : $$.width;
+    } else {
+        end = config[__axis_rotated] ? $$.width : ('end' in d ? $$.x($$.isTimeSeries() ? $$.parseDate(d.end) : d.end) : $$.width);
+    }
+    return end < start ? 0 : end - start;
+};
+c3_chart_internal_fn.regionHeight = function (d) {
+    var $$ = this, config = $$.config,
+        start = this.regionY(d), end, yScale = d.axis === 'y' ? $$.y : $$.y2;
+    if (d.axis === 'y' || d.axis === 'y2') {
+        end = config[__axis_rotated] ? $$.height : ('start' in d ? yScale(d.start) : $$.height);
+    } else {
+        end = config[__axis_rotated] ? ('end' in d ? $$.x($$.isTimeSeries() ? $$.parseDate(d.end) : d.end) : $$.height) : $$.height;
+    }
+    return end < start ? 0 : end - start;
+};
+c3_chart_internal_fn.isRegionOnX = function (d) {
+    return !d.axis || d.axis === 'x';
+};

src/scale.js

+c3_chart_internal_fn.getScale = function (min, max, forTimeseries) {
+    return (forTimeseries ? this.d3.time.scale() : this.d3.scale.linear()).range([min, max]);
+};
+c3_chart_internal_fn.getX = function (min, max, domain, offset) {
+    var $$ = this,
+        scale = $$.getScale(min, max, $$.isTimeSeries()),
+        _scale = domain ? scale.domain(domain) : scale, key;
+    // Define customized scale if categorized axis
+    if ($$.isCategorized()) {
+        offset = offset || function () { return 0; };
+        scale = function (d, raw) {
+            var v = _scale(d) + offset(d);
+            return raw ? v : Math.ceil(v);
+        };
+    } else {
+        scale = function (d, raw) {
+            var v = _scale(d);
+            return raw ? v : Math.ceil(v);
+        };
+    }
+    // define functions
+    for (key in _scale) {
+        scale[key] = _scale[key];
+    }
+    scale.orgDomain = function () {
+        return _scale.domain();
+    };
+    // define custom domain() for categorized axis
+    if ($$.isCategorized()) {
+        scale.domain = function (domain) {
+            if (!arguments.length) {
+                domain = this.orgDomain();
+                return [domain[0], domain[1] + 1];
+            }
+            _scale.domain(domain);
+            return scale;
+        };
+    }
+    return scale;
+};
+c3_chart_internal_fn.getY = function (min, max, domain) {
+    var scale = this.getScale(min, max);
+    if (domain) { scale.domain(domain); }
+    return scale;
+};
+c3_chart_internal_fn.getYScale = function (id) {
+    return this.getAxisId(id) === 'y2' ? this.y2 : this.y;
+};
+c3_chart_internal_fn.getSubYScale = function (id) {
+    return this.getAxisId(id) === 'y2' ? this.subY2 : this.subY;
+};
+c3_chart_internal_fn.updateScales = function () {
+    var $$ = this, config = $$.config,
+        forInit = !$$.x;
+    // update edges
+    $$.xMin = config[__axis_rotated] ? 1 : 0;
+    $$.xMax = config[__axis_rotated] ? $$.height : $$.width;
+    $$.yMin = config[__axis_rotated] ? 0 : $$.height;
+    $$.yMax = config[__axis_rotated] ? $$.width : 1;
+    $$.subXMin = $$.xMin;
+    $$.subXMax = $$.xMax;
+    $$.subYMin = config[__axis_rotated] ? 0 : $$.height2;
+    $$.subYMax = config[__axis_rotated] ? $$.width2 : 1;
+    // update scales
+    $$.x = $$.getX($$.xMin, $$.xMax, forInit ? undefined : $$.x.orgDomain(), function () { return $$.xAxis.tickOffset(); });
+    $$.y = $$.getY($$.yMin, $$.yMax, forInit ? undefined : $$.y.domain());
+    $$.y2 = $$.getY($$.yMin, $$.yMax, forInit ? undefined : $$.y2.domain());
+    $$.subX = $$.getX($$.xMin, $$.xMax, $$.orgXDomain, function (d) { return d % 1 ? 0 : $$.subXAxis.tickOffset(); });
+    $$.subY = $$.getY($$.subYMin, $$.subYMax, forInit ? undefined : $$.subY.domain());
+    $$.subY2 = $$.getY($$.subYMin, $$.subYMax, forInit ? undefined : $$.subY2.domain());
+    // update axes
+    $$.xAxisTickFormat = $$.getXAxisTickFormat();
+    $$.xAxisTickValues = config[__axis_x_tick_values] ? config[__axis_x_tick_values] : (forInit ? undefined : $$.xAxis.tickValues());
+    $$.xAxis = $$.getXAxis($$.x, $$.xOrient, $$.xAxisTickFormat, $$.xAxisTickValues);
+    $$.subXAxis = $$.getXAxis($$.subX, $$.subXOrient, $$.xAxisTickFormat, $$.xAxisTickValues);
+    $$.yAxis = $$.getYAxis($$.y, $$.yOrient, config[__axis_y_tick_format], config[__axis_y_ticks]);
+    $$.y2Axis = $$.getYAxis($$.y2, $$.y2Orient, config[__axis_y2_tick_format], config[__axis_y2_ticks]);
+    // Set initialized scales to brush and zoom
+    if (!forInit) {
+        if ($$.brush) { $$.brush.scale($$.subX); }
+        if (config[__zoom_enabled]) { $$.zoom.scale($$.x); }
+    }
+    // update for arc
+    if (isFunction($$.updateArc)) {
+        $$.updateArc();
+    }
+};

src/selection.js

+    c3_chart_internal_fn.selectPoint = function (target, d, i) {
+        var $$ = this, config = $$.config;
+        config[__data_onselected](d, target.node());
+        // add selected-circle on low layer g
+        $$.main.select('.' + CLASS[_selectedCircles] + $$.getTargetSelectorSuffix(d.id)).selectAll('.' + CLASS[_selectedCircle] + '-' + i)
+            .data([d])
+          .enter().append('circle')
+            .attr("class", function () { return $$.generateClass(CLASS[_selectedCircle], i); })
+            .attr("cx", config[__axis_rotated] ? $$.circleY : $$.circleX)
+            .attr("cy", config[__axis_rotated] ? $$.circleX : $$.circleY)
+            .attr("stroke", function () { return $$.color(d); })
+            .attr("r", $$.pointSelectR(d) * 1.4)
+          .transition().duration(100)
+            .attr("r", $$.pointSelectR);
+    };
+    c3_chart_internal_fn.unselectPoint = function (target, d, i) {
+        var $$ = this;
+        $$.config[__data_onunselected](d, target.node());
+        // remove selected-circle from low layer g
+        $$.main.select('.' + CLASS[_selectedCircles] + $$.getTargetSelectorSuffix(d.id)).selectAll('.' + CLASS[_selectedCircle] + '-' + i)
+          .transition().duration(100).attr('r', 0)
+            .remove();
+    };
+    c3_chart_internal_fn.togglePoint = function (selected, target, d, i) {
+        selected ? this.selectPoint(target, d, i) : this.unselectPoint(target, d, i);
+    };
+    c3_chart_internal_fn.selectBar = function (target, d) {
+        var $$ = this;
+        $$.config[__data_onselected].call($$, d, target.node());
+        target.transition().duration(100)
+            .style("fill", function () { return $$.d3.rgb($$.color(d)).brighter(0.75); });
+    };
+    c3_chart_internal_fn.unselectBar = function (target, d) {
+        var $$ = this;
+        $$.config[__data_onunselected].call($$, d, target.node());
+        target.transition().duration(100)
+            .style("fill", function () { return $$.color(d); });
+    };
+    c3_chart_internal_fn.toggleBar = function (selected, target, d, i) {
+        selected ? this.selectBar(target, d, i) : this.unselectBar(target, d, i);
+    };
+    c3_chart_internal_fn.toggleArc = function (selected, target, d, i) {
+        this.toggleBar(selected, target, d.data, i);
+    };
+    c3_chart_internal_fn.getToggle = function (that) {
+        var $$ = this;
+        // path selection not supported yet
+        return that.nodeName === 'circle' ? $$.togglePoint : ($$.d3.select(that).classed(CLASS[_bar]) ? $$.toggleBar : $$.toggleArc);
+    };
+    c3_chart_internal_fn.toggleShape = function (that, d, i) {
+        var $$ = this, d3 = $$.d3, config = $$.config,
+            shape = d3.select(that), isSelected = shape.classed(CLASS[_SELECTED]), isWithin, toggle;
+        if (that.nodeName === 'circle') {
+            isWithin = $$.isWithinCircle(that, $$.pointSelectR(d) * 1.5);
+            toggle = $$.togglePoint;
+        }
+        else if (that.nodeName === 'path') {
+            if (shape.classed(CLASS[_bar])) {
+                isWithin = $$.isWithinBar(that);
+                toggle = $$.toggleBar;
+            } else { // would be arc
+                isWithin = true;
+                toggle = $$.toggleArc;
+            }
+        }
+        if (config[__data_selection_grouped] || isWithin) {
+            if (config[__data_selection_enabled] && config[__data_selection_isselectable](d)) {
+                if (!config[__data_selection_multiple]) {
+                    $$.main.selectAll('.' + CLASS[_shapes] + (config[__data_selection_grouped] ? $$.getTargetSelectorSuffix(d.id) : "")).selectAll('.' + CLASS[_shape]).each(function (d, i) {
+                        var shape = d3.select(this);
+                        if (shape.classed(CLASS[_SELECTED])) { toggle(false, shape.classed(CLASS[_SELECTED], false), d, i); }
+                    });
+                }
+                shape.classed(CLASS[_SELECTED], !isSelected);
+                toggle(!isSelected, shape, d, i);
+            }
+            $$.config[__data_onclick](d, that);
+        }
+    };
+

src/size.js

+c3_chart_internal_fn.getCurrentWidth = function () {
+    var $$ = this, config = $$.config;
+    return config[__size_width] ? config[__size_width] : $$.getParentWidth();
+};
+c3_chart_internal_fn.getCurrentHeight = function () {
+    var $$ = this, config = $$.config,
+        h = config[__size_height] ? config[__size_height] : $$.getParentHeight();
+    return h > 0 ? h : 320;
+};
+c3_chart_internal_fn.getCurrentPaddingTop = function () {
+    var config = this.config;
+    return isValue(config[__padding_top]) ? config[__padding_top] : 0;
+};
+c3_chart_internal_fn.getCurrentPaddingBottom = function () {
+    var config = this.config;
+    return isValue(config[__padding_bottom]) ? config[__padding_bottom] : 0;
+};
+c3_chart_internal_fn.getCurrentPaddingLeft = function () {
+    var $$ = this, config = $$.config;
+    if (isValue(config[__padding_left])) {
+        return config[__padding_left];
+    } else if (config[__axis_rotated]) {
+        return !config[__axis_x_show] ? 1 : Math.max(ceil10($$.getAxisWidthByAxisId('x')), 40);
+    } else {
+        return !config[__axis_y_show] ? 1 : ceil10($$.getAxisWidthByAxisId('y'));
+    }
+};
+c3_chart_internal_fn.getCurrentPaddingRight = function () {
+    var $$ = this, config = $$.config,
+        defaultPadding = 10, legendWidthOnRight = $$.isLegendRight ? $$.getLegendWidth() + 20 : 0;
+    if (isValue(config[__padding_right])) {
+        return config[__padding_right] + 1; // 1 is needed not to hide tick line
+    } else if (config[__axis_rotated]) {
+        return defaultPadding + legendWidthOnRight;
+    } else {
+        return (!config[__axis_y2_show] ? defaultPadding : ceil10($$.getAxisWidthByAxisId('y2'))) + legendWidthOnRight;
+    }
+};
+
+c3_chart_internal_fn.getParentRectValue = function (key) {
+    var parent = this.selectChart.node(), v;
+    while (parent && parent.tagName !== 'BODY') {
+        v = parent.getBoundingClientRect()[key];
+        if (v) {
+            break;
+        }
+        parent = parent.parentNode;
+    }
+    return v;
+};
+c3_chart_internal_fn.getParentWidth = function () {
+    return this.getParentRectValue('width');
+};
+c3_chart_internal_fn.getParentHeight = function () {
+    var h = this.selectChart.style('height');
+    return h.indexOf('px') > 0 ? +h.replace('px', '') : 0;
+};
+
+
+c3_chart_internal_fn.getSvgLeft = function () {
+    var $$ = this, config = $$.config,
+        leftAxisClass = config[__axis_rotated] ? CLASS[_axisX] : CLASS[_axisY],
+        leftAxis = $$.main.select('.' + leftAxisClass).node(),
+        svgRect = leftAxis ? leftAxis.getBoundingClientRect() : {right: 0},
+        chartRect = $$.selectChart.node().getBoundingClientRect(),
+        hasArc = $$.hasArcType(),
+        svgLeft = svgRect.right - chartRect.left - (hasArc ? 0 : $$.getCurrentPaddingLeft());
+    return svgLeft > 0 ? svgLeft : 0;
+};
+
+
+c3_chart_internal_fn.getAxisWidthByAxisId = function (id) {
+    var $$ = this, position = $$.getAxisLabelPositionById(id);
+    return position.isInner ? 20 + $$.getMaxTickWidth(id) : 40 + $$.getMaxTickWidth(id);
+};
+c3_chart_internal_fn.getHorizontalAxisHeight = function (axisId) {
+    var $$ = this, config = $$.config;
+    if (axisId === 'x' && !config[__axis_x_show]) { return 0; }
+    if (axisId === 'x' && config[__axis_x_height]) { return config[__axis_x_height]; }
+    if (axisId === 'y' && !config[__axis_y_show]) { return config[__legend_show] && !$$.isLegendRight && !$$.isLegendInset ? 10 : 1; }
+    if (axisId === 'y2' && !config[__axis_y2_show]) { return $$.rotated_padding_top; }
+    return ($$.getAxisLabelPositionById(axisId).isInner ? 30 : 40) + (axisId === 'y2' ? -10 : 0);
+};
+
+c3_chart_internal_fn.getEventRectWidth = function () {
+    var $$ = this;
+    var target = $$.getMaxDataCountTarget($$.data.targets),
+        firstData, lastData, base, maxDataCount, ratio, w;
+    if (!target) {
+        return 0;
+    }
+    firstData = target.values[0], lastData = target.values[target.values.length - 1];
+    base = $$.x(lastData.x) - $$.x(firstData.x);
+    if (base === 0) {
+        return $$.config[__axis_rotated] ? $$.height : $$.width;
+    }
+    maxDataCount = $$.getMaxDataCount();
+    ratio = ($$.hasType('bar') ? (maxDataCount - ($$.isCategorized() ? 0.25 : 1)) / maxDataCount : 1);
+    w = maxDataCount > 1 ? (base * ratio) / (maxDataCount - 1) : base;
+    return w < 1 ? 1 : w;
+};

src/subchart.js

+c3_chart_internal_fn.initBrush = function () {
+    var $$ = this, d3 = $$.d3;
+    $$.brush = d3.svg.brush().on("brush", function () { $$.redrawForBrush(); });
+    $$.brush.update = function () {
+        if ($$.context) { $$.context.select('.' + $$.CLASS[_brush]).call(this); }
+        return this;
+    };
+    $$.brush.scale = function (scale) {
+        return $$.config[__axis_rotated] ? this.y(scale) : this.x(scale);
+    };
+};
+c3_chart_internal_fn.initSubchart = function () {
+    var $$ = this, config = $$.config,
+        context = $$.context = $$.svg.append("g").attr("transform", $$.getTranslate('context'));
+
+    if (!config[__subchart_show]) {
+        context.style('visibility', 'hidden');
+    }
+
+    // Define g for chart area
+    context.append('g')
+        .attr("clip-path", $$.clipPath)
+        .attr('class', CLASS[_chart]);
+
+    // Define g for bar chart area
+    context.select('.' + CLASS[_chart]).append("g")
+        .attr("class", CLASS[_chartBars]);
+
+    // Define g for line chart area
+    context.select('.' + CLASS[_chart]).append("g")
+        .attr("class", CLASS[_chartLines]);
+
+    // Add extent rect for Brush
+    context.append("g")
+        .attr("clip-path", $$.clipPath)
+        .attr("class", CLASS[_brush])
+        .call($$.brush)
+        .selectAll("rect")
+        .attr(config[__axis_rotated] ? "width" : "height", config[__axis_rotated] ? $$.width2 : $$.height2);
+
+    // ATTENTION: This must be called AFTER chart added
+    // Add Axis
+    $$.axes.subx = context.append("g")
+        .attr("class", CLASS[_axisX])
+        .attr("transform", $$.getTranslate('subx'))
+        .attr("clip-path", config[__axis_rotated] ? "" : $$.clipPathForXAxis);
+};
+c3_chart_internal_fn.updateTargetsForSubchart = function (targets) {
+    var $$ = this, context = $$.context, config = $$.config,
+        contextLineEnter, contextLineUpdate, contextBarEnter, contextBarUpdate;
+
+    if (config[__subchart_show]) {
+
+        contextBarUpdate = context.select('.' + CLASS[_chartBars]).selectAll('.' + CLASS[_chartBar])
+            .data(targets)
+            .attr('class', generateCall($$.classChartBar, $$));
+        contextBarEnter = contextBarUpdate.enter().append('g')
+            .style('opacity', 0)
+            .attr('class', generateCall($$.classChartBar, $$));
+        // Bars for each data
+        contextBarEnter.append('g')
+            .attr("class", generateCall($$.classBars, $$));
+
+        //-- Line --//
+        contextLineUpdate = context.select('.' + CLASS[_chartLines]).selectAll('.' + CLASS[_chartLine])
+            .data(targets)
+            .attr('class', generateCall($$.classChartLine, $$));
+        contextLineEnter = contextLineUpdate.enter().append('g')
+            .style('opacity', 0)
+            .attr('class', generateCall($$.classChartLine, $$));
+        // Lines for each data
+        contextLineEnter.append("g")
+            .attr("class", generateCall($$.classLines, $$));
+        // Area
+        contextLineEnter.append("g")
+            .attr("class", generateCall($$.classAreas, $$));
+    }
+};
+c3_chart_internal_fn.redrawSubchart = function (withSubchart, transitions, duration, durationForExit, areaIndices, barIndices, lineIndices) {
+    var $$ = this, d3 = $$.d3, context = $$.context, config = $$.config,
+        contextLine,  contextArea, contextBar, drawAreaOnSub, drawBarOnSub, drawLineOnSub;
+
+    // subchart
+    if (config[__subchart_show]) {
+        // reflect main chart to extent on subchart if zoomed
+        if (d3.event && d3.event.type === 'zoom') {
+            $$.brush.extent($$.x.orgDomain()).update();
+        }
+        // update subchart elements if needed
+        if (withSubchart) {
+
+            // rotate tick text if needed
+            if (!config[__axis_rotated] && config[__axis_x_tick_rotate]) {
+                $$.rotateTickText($$.axes.subx, transitions.axisSubX, config[__axis_x_tick_rotate]);
+            }
+
+            // extent rect
+            if (!$$.brush.empty()) {
+                $$.brush.extent($$.x.orgDomain()).update();
+            }
+            // setup drawer - MEMO: this must be called after axis updated
+            drawAreaOnSub = $$.generateDrawArea(areaIndices, true);
+            drawBarOnSub = $$.generateDrawBar(barIndices, true);
+            drawLineOnSub = $$.generateDrawLine(lineIndices, true);
+            // bars
+            contextBar = context.selectAll('.' + CLASS[_bars]).selectAll('.' + CLASS[_bar])
+                .data(generateCall($$.barData, $$));
+            contextBar.enter().append('path')
+                .attr("class", generateCall($$.classBar, $$))
+                .style("stroke", 'none')
+                .style("fill", $$.color);
+            contextBar
+                .style("opacity", generateCall($$.initialOpacity, $$))
+                .transition().duration(duration)
+                .attr('d', drawBarOnSub)
+                .style('opacity', 1);
+            contextBar.exit().transition().duration(duration)
+                .style('opacity', 0)
+                .remove();
+            // lines
+            contextLine = context.selectAll('.' + CLASS[_lines]).selectAll('.' + CLASS[_line])
+                .data(generateCall($$.lineData, $$));
+            contextLine.enter().append('path')
+                .attr('class', generateCall($$.classLine, $$))
+                .style('stroke', $$.color);
+            contextLine
+                .style("opacity", generateCall($$.initialOpacity, $$))
+                .transition().duration(duration)
+                .attr("d", drawLineOnSub)
+                .style('opacity', 1);
+            contextLine.exit().transition().duration(duration)
+                .style('opacity', 0)
+                .remove();
+            // area
+            contextArea = context.selectAll('.' + CLASS[_areas]).selectAll('.' + CLASS[_area])
+                .data(generateCall($$.lineData, $$));
+            contextArea.enter().append('path')
+                .attr("class", generateCall($$.classArea, $$))
+                .style("fill", $$.color)
+                .style("opacity", function () { $$.orgAreaOpacity = +d3.select(this).style('opacity'); return 0; });
+            contextArea
+                .style("opacity", 0)
+                .transition().duration(duration)
+                .attr("d", drawAreaOnSub)
+                .style("fill", $$.color)
+                .style("opacity", $$.orgAreaOpacity);
+            contextArea.exit().transition().duration(durationForExit)
+                .style('opacity', 0)
+                .remove();
+        }
+    }
+};
+c3_chart_internal_fn.redrawForBrush = function () {
+    var $$ = this, x = $$.x;
+    $$.redraw({
+        withTransition: false,
+        withY: false,
+        withSubchart: false,
+        withUpdateXDomain: true
+    });
+    $$.config[__subchart_onbrush].call($$, x.orgDomain());
+};
+c3_chart_internal_fn.transformContext = function (withTransition, transitions) {
+    var $$ = this, subXAxis;
+    if (transitions && transitions.axisSubX) {
+        subXAxis = transitions.axisSubX;
+    } else {
+        subXAxis = $$.context.select('.' + CLASS[_axisX]);
+        if (withTransition) { subXAxis = subXAxis.transition(); }
+    }
+    $$.context.attr("transform", $$.getTranslate('context'));
+    subXAxis.attr("transform", $$.getTranslate('subx'));
+};

src/tail.js

+    if (typeof define === 'function' && define.amd) {
+        define("c3", ["d3"], c3);
+    } else if ('undefined' !== typeof exports && 'undefined' !== typeof module) {
+        module.exports = c3;
+    } else {
+        window.c3 = c3;
+    }
+
+})(window);

src/text.js

+c3_chart_internal_fn.getTextRect = function (text, cls) {
+    var rect;
+    this.d3.select('body').selectAll('.dummy')
+        .data([text])
+      .enter().append('text')
+        .classed(cls ? cls : "", true)
+        .text(text)
+      .each(function () { rect = this.getBoundingClientRect(); })
+        .remove();
+    return rect;
+};

src/tooltip.js

+c3_chart_internal_fn.initTooltip = function () {
+    var $$ = this, config = $$.config, i;
+    $$.tooltip = $$.selectChart
+        .style("position", "relative")
+        .append("div")
+        .style("position", "absolute")
+        .style("pointer-events", "none")
+        .style("z-index", "10")
+        .style("display", "none");
+    // Show tooltip if needed
+    if (config[__tooltip_init_show]) {
+        if ($$.isTimeSeries() && isString(config[__tooltip_init_x])) {
+            config[__tooltip_init_x] = $$.parseDate(config[__tooltip_init_x]);
+            for (i = 0; i < $$.data.targets[0].values.length; i++) {
+                if (($$.data.targets[0].values[i].x - config[__tooltip_init_x]) === 0) { break; }
+            }
+            config[__tooltip_init_x] = i;
+        }
+        $$.tooltip.html(config[__tooltip_contents].call($$, $$.data.targets.map(function (d) {
+            return $$.addName(d.values[config[__tooltip_init_x]]);
+        }), $$.getXAxisTickFormat(), $$.getYFormat($$.hasArcType()), $$.color));
+        $$.tooltip.style("top", config[__tooltip_init_position].top)
+            .style("left", config[__tooltip_init_position].left)
+            .style("display", "block");
+    }
+};
+c3_chart_internal_fn.getTooltipContent = function (d, defaultTitleFormat, defaultValueFormat, color) {
+    var $$ = this, config = $$.config,
+        titleFormat = config[__tooltip_format_title] || defaultTitleFormat,
+        nameFormat = config[__tooltip_format_name] || function (name) { return name; },
+        valueFormat = config[__tooltip_format_value] || defaultValueFormat,
+        text, i, title, value, name, bgcolor;
+    for (i = 0; i < d.length; i++) {
+        if (! (d[i] && (d[i].value || d[i].value === 0))) { continue; }
+
+        if (! text) {
+            title = titleFormat ? titleFormat(d[i].x) : d[i].x;
+            text = "<table class='" + CLASS[_tooltip] + "'>" + (title || title === 0 ? "<tr><th colspan='2'>" + title + "</th></tr>" : "");
+        }
+
+        name = nameFormat(d[i].name);
+        value = valueFormat(d[i].value, d[i].ratio, d[i].id, d[i].index);
+        bgcolor = $$.levelColor ? $$.levelColor(d[i].value) : color(d[i].id);
+
+        text += "<tr class='" + CLASS[_tooltipName] + "-" + d[i].id + "'>";
+        text += "<td class='name'><span style='background-color:" + bgcolor + "'></span>" + name + "</td>";
+        text += "<td class='value'>" + value + "</td>";
+        text += "</tr>";
+    }
+    return text + "</table>";
+};
+c3_chart_internal_fn.showTooltip = function (selectedData, mouse) {
+    var $$ = this, config = $$.config;
+    var tWidth, tHeight, svgLeft, tooltipLeft, tooltipRight, tooltipTop, chartRight;
+    var forArc = $$.hasArcType(),
+        dataToShow = selectedData.filter(function (d) { return d && isValue(d.value); });
+    if (dataToShow.length === 0 || !config[__tooltip_show]) {
+        return;
+    }
+    $$.tooltip.html(config[__tooltip_contents].call($$, selectedData, $$.getXAxisTickFormat(), $$.getYFormat(forArc), $$.color)).style("display", "block");
+
+    // Get tooltip dimensions
+    tWidth = $$.tooltip.property('offsetWidth');
+    tHeight = $$.tooltip.property('offsetHeight');
+    // Determin tooltip position
+    if (forArc) {
+        tooltipLeft = ($$.width / 2) + mouse[0];
+        tooltipTop = ($$.height / 2) + mouse[1] + 20;
+    } else {
+        if (config[__axis_rotated]) {
+            svgLeft = $$.getSvgLeft();
+            tooltipLeft = svgLeft + mouse[0] + 100;
+            tooltipRight = tooltipLeft + tWidth;
+            chartRight = $$.getCurrentWidth() - $$.getCurrentPaddingRight();
+            tooltipTop = $$.x(dataToShow[0].x) + 20;
+        } else {
+            svgLeft = $$.getSvgLeft();
+            tooltipLeft = svgLeft + $$.getCurrentPaddingLeft() + $$.x(dataToShow[0].x) + 20;
+            tooltipRight = tooltipLeft + tWidth;
+            chartRight = svgLeft + $$.getCurrentWidth() - $$.getCurrentPaddingRight();
+            tooltipTop = mouse[1] + 15;
+        }
+
+        if (tooltipRight > chartRight) {
+            tooltipLeft -= tooltipRight - chartRight;
+        }
+        if (tooltipTop + tHeight > $$.getCurrentHeight()) {
+            tooltipTop -= tHeight + 30;
+        }
+    }
+    // Set tooltip
+    $$.tooltip
+        .style("top", tooltipTop + "px")
+        .style("left", tooltipLeft + 'px');
+};
+c3_chart_internal_fn.hideTooltip = function () {
+    this.tooltip.style("display", "none");
+};

src/type.js

+c3_chart_internal_fn.setTargetType = function (targetIds, type) {
+    var $$ = this, config = $$.config;
+    $$.mapToTargetIds(targetIds).forEach(function (id) {
+        $$.withoutFadeIn[id] = (type === config[__data_types][id]);
+        config[__data_types][id] = type;
+    });
+    if (!targetIds) {
+        config[__data_type] = type;
+    }
+};
+c3_chart_internal_fn.hasType = function (type, targets) {
+    var $$ = this, types = $$.config[__data_types], has = false;
+    (targets || $$.data.targets).forEach(function (t) {
+        if ((types[t.id] && types[t.id].indexOf(type) >= 0) || (!(t.id in types) && type === 'line')) {
+            has = true;
+        }
+    });
+    return has;
+};
+c3_chart_internal_fn.hasArcType = function (targets) {
+    return this.hasType('pie', targets) || this.hasType('donut', targets) || this.hasType('gauge', targets);
+};
+c3_chart_internal_fn.isLineType = function (d) {
+    var config = this.config, id = isString(d) ? d : d.id;
+    return !config[__data_types][id] || ['line', 'spline', 'area', 'area-spline', 'step', 'area-step'].indexOf(config[__data_types][id]) >= 0;
+};
+c3_chart_internal_fn.isStepType = function (d) {
+    var id = isString(d) ? d : d.id;
+    return ['step', 'area-step'].indexOf(this.config[__data_types][id]) >= 0;
+};
+c3_chart_internal_fn.isSplineType = function (d) {
+    var id = isString(d) ? d : d.id;
+    return ['spline', 'area-spline'].indexOf(this.config[__data_types][id]) >= 0;
+};
+c3_chart_internal_fn.isAreaType = function (d) {
+    var id = isString(d) ? d : d.id;
+    return ['area', 'area-spline', 'area-step'].indexOf(this.config[__data_types][id]) >= 0;
+};
+c3_chart_internal_fn.isBarType = function (d) {
+    var id = isString(d) ? d : d.id;
+    return this.config[__data_types][id] === 'bar';
+};
+c3_chart_internal_fn.isScatterType = function (d) {
+    var id = isString(d) ? d : d.id;
+    return this.config[__data_types][id] === 'scatter';
+};
+c3_chart_internal_fn.isPieType = function (d) {
+    var id = isString(d) ? d : d.id;
+    return this.config[__data_types][id] === 'pie';
+};
+c3_chart_internal_fn.isGaugeType = function (d) {
+    var id = isString(d) ? d : d.id;
+    return this.config[__data_types][id] === 'gauge';
+};
+c3_chart_internal_fn.isDonutType = function (d) {
+    var id = isString(d) ? d : d.id;
+    return this.config[__data_types][id] === 'donut';
+};
+c3_chart_internal_fn.isArcType = function (d) {
+    return this.isPieType(d) || this.isDonutType(d) || this.isGaugeType(d);
+};
+c3_chart_internal_fn.lineData = function (d) {
+    return this.isLineType(d) ? [d] : [];
+};
+c3_chart_internal_fn.arcData = function (d) {
+    return this.isArcType(d.data) ? [d] : [];
+};
+/* not used
+ function scatterData(d) {
+ return isScatterType(d) ? d.values : [];
+ }
+ */
+c3_chart_internal_fn.barData = function (d) {
+    return this.isBarType(d) ? d.values : [];
+};
+c3_chart_internal_fn.lineOrScatterData = function (d) {
+    return this.isLineType(d) || this.isScatterType(d) ? d.values : [];
+};
+c3_chart_internal_fn.barOrLineData = function (d) {
+    return this.isBarType(d) || this.isLineType(d) ? d.values : [];
+};

src/util.js

+var isValue = c3_chart_internal_fn.isValue = function (v) {
+    return v || v === 0;
+},
+    isFunction = c3_chart_internal_fn.isFunction = function (o) {
+        return typeof o === 'function';
+    },
+    isString = c3_chart_internal_fn.isString = function (o) {
+        return typeof o === 'string';
+    },
+    isUndefined = c3_chart_internal_fn.isUndefined = function (v) {
+        return typeof v === 'undefined';
+    },
+    isDefined = c3_chart_internal_fn.isDefined = function (v) {
+        return typeof v !== 'undefined';
+    },
+    ceil10 = c3_chart_internal_fn.ceil10 = function (v) {
+        return Math.ceil(v / 10) * 10;
+    },
+    asHalfPixel = c3_chart_internal_fn.asHalfPixel = function (n) {
+        return Math.ceil(n) + 0.5;
+    },
+    diffDomain = c3_chart_internal_fn.diffDomain = function (d) {
+        return d[1] - d[0];
+    },
+    isEmpty = c3_chart_internal_fn.isEmpty = function (o) {
+        return !o || (isString(o) && o.length === 0) || (typeof o === 'object' && Object.keys(o).length === 0);
+    },
+    notEmpty = c3_chart_internal_fn.notEmpty = function (o) {
+        return Object.keys(o).length > 0;
+    },
+    getOption = c3_chart_internal_fn.getOption = function (options, key, defaultValue) {
+        return isDefined(options[key]) ? options[key] : defaultValue;
+    },
+    hasValue = c3_chart_internal_fn.hasValue = function (dict, value) {
+        var found = false;
+        Object.keys(dict).forEach(function (key) {
+            if (dict[key] === value) { found = true; }
+        });
+        return found;
+    },
+    getPathBox = c3_chart_internal_fn.getPathBox = function (path) {
+        var box = path.getBoundingClientRect(),
+            items = [path.pathSegList.getItem(0), path.pathSegList.getItem(1)],
+            minX = items[0].x, minY = Math.min(items[0].y, items[1].y);
+        return {x: minX, y: minY, width: box.width, height: box.height};
+    },
+    generateCall = c3_chart_internal_fn.generateCall = function (f, context) {
+        return function (d, i) { return f.call(context, d, i); };
+    };

src/zoom.js

+c3_chart_internal_fn.initZoom = function () {
+    var $$ = this, d3 = $$.d3, config = $$.config;
+    $$.zoom = d3.behavior.zoom()
+        .on("zoomstart", function () {
+            $$.zoom.altDomain = d3.event.sourceEvent.altKey ? $$.x.orgDomain() : null;
+        })
+        .on("zoom", $$.redrawForZoom);
+    $$.zoom.scale = function (scale) {
+        return config[__axis_rotated] ? this.y(scale) : this.x(scale);
+    };
+    $$.zoom.orgScaleExtent = function () {
+        var extent = config[__zoom_extent] ? config[__zoom_extent] : [1, 10];
+        return [extent[0], Math.max($$.getMaxDataCount() / extent[1], extent[1])];
+    };
+    $$.zoom.updateScaleExtent = function () {
+        var ratio = diffDomain($$.x.orgDomain()) / diffDomain($$.orgXDomain),
+            extent = $$.orgScaleExtent();
+        $$.scaleExtent([extent[0] * ratio, extent[1] * ratio]);
+        return this;
+    };
+};
+c3_chart_internal_fn.updateZoom = function () {
+    var $$ = this, z = $$.config[__zoom_enabled] ? $$.zoom : function () {};
+    $$.main.select('.' + $$.CLASS[_zoomRect]).call(z);
+    $$.main.selectAll('.' + $$.CLASS[_eventRect]).call(z);
+};
+c3_chart_internal_fn.redrawForZoom = function () {
+    var $$ = this, d3 = $$.d3, config = $$.config, zoom = $$.zoom, x = $$.x, orgXDomain = $$.orgXDomain;
+    if (!config[__zoom_enabled]) {
+        return;
+    }
+    if ($$.filterTargetsToShow($$.data.targets).length === 0) {
+        return;
+    }
+    if (d3.event.sourceEvent.type === 'mousemove' && zoom.altDomain) {
+        x.domain(zoom.altDomain);
+        zoom.scale(x).updateScaleExtent();
+        return;
+    }
+    if ($$.isCategorized() && x.orgDomain()[0] === orgXDomain[0]) {
+        x.domain([orgXDomain[0] - 1e-10, x.orgDomain()[1]]);
+    }
+    $$.redraw({
+        withTransition: false,
+        withY: false,
+        withSubchart: false
+    });
+    if (d3.event.sourceEvent.type === 'mousemove') {
+        $$.cancelClick = true;
+    }
+    config[__zoom_onzoom].call(c3, x.orgDomain());
+};