cx 24.3.11 → 24.4.1

package/dist/charts.css

@@ -253,6 +253,12 @@
   fill: lightgray;
 }
 
+.cxe-rangemarker-path {
+  stroke: #696969;
+  fill: none;
+  stroke-width: 1px;
+}
+
 .cxs-color-0 {
   fill: #fbb4af;
   stroke: #e2a29e;

package/dist/charts.js

@@ -544,8 +544,9 @@ var PieChart = /*#__PURE__*/ (function (_BoundedObject) {
 			[this].concat(Array.prototype.slice.call(arguments), [
 				{
 					angle: undefined,
-					startAngle: 0,
+					startAngle: undefined,
 					clockwise: undefined,
+					gap: undefined,
 				},
 			]),
 		);
@@ -553,7 +554,7 @@ var PieChart = /*#__PURE__*/ (function (_BoundedObject) {
 	_proto.explore = function explore(context, instance) {
 		if (!instance.pie) instance.pie = new PieCalculator();
 		var data = instance.data;
-		instance.pie.reset(data.angle, data.startAngle, data.clockwise);
+		instance.pie.reset(data.angle, data.startAngle, data.clockwise, data.gap);
 		context.push("pie", instance.pie);
 		_BoundedObject.prototype.explore.call(this, context, instance);
 	};
@@ -577,19 +578,28 @@ PieChart.prototype.anchors = "0 1 1 0";
 var PieCalculator = /*#__PURE__*/ (function () {
 	function PieCalculator() {}
 	var _proto2 = PieCalculator.prototype;
-	_proto2.reset = function reset(angle, startAngle, clockwise) {
+	_proto2.reset = function reset(angle, startAngle, clockwise, gap) {
+		if (angle == 360) angle = 359.99; // really hacky way to draw full circles
 		this.angleTotal = (angle / 180) * Math.PI;
 		this.startAngle = (startAngle / 180) * Math.PI;
 		this.clockwise = clockwise;
+		this.gap = gap;
 		this.stacks = {};
 	};
-	_proto2.acknowledge = function acknowledge(stack, value) {
+	_proto2.acknowledge = function acknowledge(stack, value, r, r0, percentageRadius) {
 		var s = this.stacks[stack];
 		if (!s)
 			s = this.stacks[stack] = {
 				total: 0,
+				r0s: this.gap > 0 ? [] : null,
+				r0ps: this.gap > 0 ? [] : null,
 			};
-		if (value > 0) s.total += value;
+		if (value > 0) {
+			s.total += value;
+			if (this.gap > 0 && r0 > 0)
+				if (percentageRadius) s.r0ps.push(r0);
+				else s.r0s.push(r0);
+		}
 	};
 	_proto2.hash = function hash() {
 		var _this = this;
@@ -605,28 +615,58 @@ var PieCalculator = /*#__PURE__*/ (function () {
 			cx: this.cx,
 			cy: this.cy,
 			R: this.R,
+			gap: this.gap,
 		};
 	};
 	_proto2.measure = function measure(rect) {
+		this.R = Math.max(0, Math.min(rect.width(), rect.height())) / 2;
 		for (var s in this.stacks) {
 			var stack = this.stacks[s];
-			stack.angleFactor = stack.total > 0 ? this.angleTotal / stack.total : 0;
+			var gapAngleTotal = 0;
+			stack.gap = this.gap;
+			if (this.gap > 0) {
+				// gap cannot be larger of two times the smallest r0
+				for (var index = 0; index < stack.r0s.length; index++)
+					if (2 * stack.r0s[index] < stack.gap) stack.gap = 2 * stack.r0s[index];
+				for (var _index = 0; _index < stack.r0ps.length; _index++) {
+					var r0 = (stack.r0ps[_index] * this.R) / 100;
+					if (2 * r0 < stack.gap) stack.gap = 2 * r0;
+				}
+			}
+			while (stack.gap > 0) {
+				for (var _index2 = 0; _index2 < stack.r0s.length; _index2++)
+					gapAngleTotal += Math.asin(stack.gap / stack.r0s[_index2] / 2);
+				for (var _index3 = 0; _index3 < stack.r0ps.length; _index3++)
+					gapAngleTotal += Math.asin(stack.gap / ((stack.r0ps[_index3] * this.R) / 100) / 2);
+				if (gapAngleTotal < 0.25 * this.angleTotal) break;
+				stack.gap = stack.gap * 0.9;
+				gapAngleTotal = 0;
+			}
+			if (gapAngleTotal == 0) stack.gap = 0;
+			stack.angleFactor = stack.total > 0 ? (this.angleTotal - gapAngleTotal) / stack.total : 0;
 			stack.lastAngle = this.startAngle;
 		}
 		this.cx = (rect.l + rect.r) / 2;
 		this.cy = (rect.t + rect.b) / 2;
-		this.R = Math.max(0, Math.min(rect.width(), rect.height())) / 2;
 	};
-	_proto2.map = function map(stack, value) {
+	_proto2.map = function map(stack, value, r, r0, percentageRadius) {
+		if (percentageRadius) {
+			r = (r * this.R) / 100;
+			r0 = (r0 * this.R) / 100;
+		}
 		var s = this.stacks[stack];
 		var angle = value * s.angleFactor;
 		var startAngle = s.lastAngle;
-		if (!this.clockwise) s.lastAngle += angle;
-		else s.lastAngle -= angle;
+		var clockFactor = this.clockwise ? -1 : 1;
+		var gapAngle = r0 > 0 && s.gap > 0 ? Math.asin(s.gap / r0 / 2) : 0;
+		s.lastAngle += clockFactor * (angle + gapAngle);
+		var endAngle = startAngle + clockFactor * angle + gapAngle;
 		return {
 			startAngle: startAngle,
-			endAngle: s.lastAngle,
-			midAngle: (startAngle + s.lastAngle) / 2,
+			endAngle: startAngle + clockFactor * angle + gapAngle,
+			angle: angle,
+			midAngle: (startAngle + endAngle) / 2,
+			gap: s.gap,
 			cx: this.cx,
 			cy: this.cy,
 			R: this.R,
@@ -634,101 +674,134 @@ var PieCalculator = /*#__PURE__*/ (function () {
 	};
 	return PieCalculator;
 })();
-function createSvgArc(x, y, r0, r, startAngleRadian, endAngleRadian, br) {
+function createSvgArc(cx, cy, r0, r, startAngle, endAngle, br, gap) {
 	if (r0 === void 0) {
 		r0 = 0;
 	}
 	if (br === void 0) {
 		br = 0;
 	}
-	if (startAngleRadian > endAngleRadian) {
-		var s = startAngleRadian;
-		startAngleRadian = endAngleRadian;
-		endAngleRadian = s;
+	if (gap === void 0) {
+		gap = 0;
+	}
+	var gap2 = gap / 2;
+	if (startAngle > endAngle) {
+		var s = startAngle;
+		startAngle = endAngle;
+		endAngle = s;
 	}
 	var path = [];
 	// limit br size based on r and r0
 	if (br > (r - r0) / 2) br = (r - r0) / 2;
-	var largeArc = endAngleRadian - startAngleRadian > Math.PI ? 1 : 0;
 	if (br > 0) {
 		if (r0 > 0) {
 			var innerBr = br;
-			var innerSmallArcAngle = Math.asin(br / (r0 + br));
-			if (innerSmallArcAngle > (endAngleRadian - startAngleRadian) / 2) {
-				innerSmallArcAngle = (endAngleRadian - startAngleRadian) / 2;
+			var innerSmallArcAngle = Math.asin((br + gap2) / (r0 + br));
+
+			// adjust br according to the available area
+			if (innerSmallArcAngle > (endAngle - startAngle) / 2) {
+				innerSmallArcAngle = (endAngle - startAngle) / 2;
 				var sin = Math.sin(innerSmallArcAngle);
-				// correct br according to newly calculated border radius angle
-				innerBr = (r0 * sin) / (1 - sin);
+				innerBr = (r0 * sin - gap2) / (1 - sin);
 			}
-			var innerHip = Math.cos(innerSmallArcAngle) * (r0 + innerBr);
-			var innerSmallArc1XFrom = x + Math.cos(endAngleRadian) * innerHip;
-			var innerSmallArc1YFrom = y - Math.sin(endAngleRadian) * innerHip;
+			var innerHipDiagonal = (r0 + innerBr) * Math.cos(innerSmallArcAngle);
+			var innerSmallArc1XFrom = cx + Math.cos(endAngle) * innerHipDiagonal + Math.cos(endAngle - Math.PI / 2) * gap2;
+			var innerSmallArc1YFrom = cy - Math.sin(endAngle) * innerHipDiagonal - Math.sin(endAngle - Math.PI / 2) * gap2;
 
 			// move from the first small inner arc
 			path.push(move(innerSmallArc1XFrom, innerSmallArc1YFrom));
-			var innerSmallArc1XTo = x + Math.cos(endAngleRadian - innerSmallArcAngle) * r0;
-			var innerSmallArc1YTo = y - Math.sin(endAngleRadian - innerSmallArcAngle) * r0;
+			var innerSmallArc1XTo = cx + Math.cos(endAngle - innerSmallArcAngle) * r0;
+			var innerSmallArc1YTo = cy - Math.sin(endAngle - innerSmallArcAngle) * r0;
 
 			// add first small inner arc
 			path.push(arc(innerBr, innerBr, 0, 0, 0, innerSmallArc1XTo, innerSmallArc1YTo));
-			var innerArcXTo = x + Math.cos(startAngleRadian + innerSmallArcAngle) * r0;
-			var innerArcYTo = y - Math.sin(startAngleRadian + innerSmallArcAngle) * r0;
 
+			// SECOND ARC
+
+			var innerArcXTo = cx + Math.cos(startAngle + innerSmallArcAngle) * r0;
+			var innerArcYTo = cy - Math.sin(startAngle + innerSmallArcAngle) * r0;
 			// add large inner arc
-			path.push(arc(r0, r0, 0, largeArc, 1, innerArcXTo, innerArcYTo));
-			var innerSmallArc2XTo = x + Math.cos(startAngleRadian) * innerHip;
-			var innerSmallArc2YTo = y - Math.sin(startAngleRadian) * innerHip;
+			path.push(
+				arc(
+					r0,
+					r0,
+					0,
+					largeArcFlag(endAngle - innerSmallArcAngle - startAngle - innerSmallArcAngle),
+					1,
+					innerArcXTo,
+					innerArcYTo,
+				),
+			);
+			var innerSmallArc2XTo = cx + Math.cos(startAngle) * innerHipDiagonal + Math.cos(startAngle + Math.PI / 2) * gap2;
+			var innerSmallArc2YTo = cy - Math.sin(startAngle) * innerHipDiagonal - Math.sin(startAngle + Math.PI / 2) * gap2;
 			// add second small inner arc
 			path.push(arc(innerBr, innerBr, 0, 0, 0, innerSmallArc2XTo, innerSmallArc2YTo));
 		} else {
-			path.push(move(x, y));
+			path.push(move(cx, cy));
 		}
 		var outerBr = br;
-		var outerSmallArcAngle = Math.asin(br / (r - br));
-		if (outerSmallArcAngle > (endAngleRadian - startAngleRadian) / 2) {
-			outerSmallArcAngle = (endAngleRadian - startAngleRadian) / 2;
+		var outerSmallArcAngle = Math.asin((br + gap2) / (r - br));
+
+		// tweak br according to the available area
+		if (outerSmallArcAngle > (endAngle - startAngle) / 2) {
+			outerSmallArcAngle = (endAngle - startAngle) / 2;
 			var _sin = Math.sin(outerSmallArcAngle);
-			// correct br according to newly calculated border radius angle
-			outerBr = (r * _sin) / (1 + _sin);
+			outerBr = (r * _sin - gap2) / (1 + _sin);
 		}
-		var outerHip = Math.cos(outerSmallArcAngle) * (r - outerBr);
-		var outerSmallArc1XFrom = x + Math.cos(startAngleRadian) * outerHip;
-		var outerSmallArc1YFrom = y - Math.sin(startAngleRadian) * outerHip;
-		var outerSmallArc1XTo = x + Math.cos(startAngleRadian + outerSmallArcAngle) * r;
-		var outerSmallArc1YTo = y - Math.sin(startAngleRadian + outerSmallArcAngle) * r;
-		var outerLargeArcXTo = x + Math.cos(endAngleRadian - outerSmallArcAngle) * r;
-		var outerLargeArcYTo = y - Math.sin(endAngleRadian - outerSmallArcAngle) * r;
-		var outerSmallArc2XTo = x + Math.cos(endAngleRadian) * outerHip;
-		var outerSmallArc2YTo = y - Math.sin(endAngleRadian) * outerHip;
+		var outerHipDiagonal = Math.cos(outerSmallArcAngle) * (r - outerBr);
+		var outerSmallArc1XFrom = cx + Math.cos(startAngle) * outerHipDiagonal + Math.cos(startAngle + Math.PI / 2) * gap2;
+		var outerSmallArc1YFrom = cy - Math.sin(startAngle) * outerHipDiagonal - Math.sin(startAngle + Math.PI / 2) * gap2;
+		var outerSmallArc1XTo = cx + Math.cos(startAngle + outerSmallArcAngle) * r;
+		var outerSmallArc1YTo = cy - Math.sin(startAngle + outerSmallArcAngle) * r;
+		var outerLargeArcXTo = cx + Math.cos(endAngle - outerSmallArcAngle) * r;
+		var outerLargeArcYTo = cy - Math.sin(endAngle - outerSmallArcAngle) * r;
+		var outerSmallArc2XTo = cx + Math.cos(endAngle) * outerHipDiagonal + Math.cos(endAngle - Math.PI / 2) * gap2;
+		var outerSmallArc2YTo = cy - Math.sin(endAngle) * outerHipDiagonal - Math.sin(endAngle - Math.PI / 2) * gap2;
 		path.push(
 			line$1(outerSmallArc1XFrom, outerSmallArc1YFrom),
 			arc(outerBr, outerBr, 0, 0, 0, outerSmallArc1XTo, outerSmallArc1YTo),
-			arc(r, r, 0, largeArc, 0, outerLargeArcXTo, outerLargeArcYTo),
+			arc(
+				r,
+				r,
+				0,
+				largeArcFlag(endAngle - outerSmallArcAngle - startAngle - outerSmallArcAngle),
+				0,
+				outerLargeArcXTo,
+				outerLargeArcYTo,
+			),
 			arc(outerBr, outerBr, 0, 0, 0, outerSmallArc2XTo, outerSmallArc2YTo),
 		);
 	} else {
 		if (r0 > 0) {
-			var startX = x + Math.cos(endAngleRadian) * r0;
-			var startY = y - Math.sin(endAngleRadian) * r0;
+			var innerGapAngle = r0 > 0 && gap2 > 0 ? Math.asin(gap2 / r0) : 0;
+			var innerStartAngle = startAngle + innerGapAngle;
+			var innerEndAngle = endAngle - innerGapAngle;
+			var startX = cx + Math.cos(innerEndAngle) * r0;
+			var startY = cy - Math.sin(innerEndAngle) * r0;
 			path.push(move(startX, startY));
-			var innerArcToX = x + Math.cos(startAngleRadian) * r0;
-			var innerArcToY = y - Math.sin(startAngleRadian) * r0;
-			path.push(arc(r0, r0, 0, largeArc, 1, innerArcToX, innerArcToY));
+			var innerArcToX = cx + Math.cos(innerStartAngle) * r0;
+			var innerArcToY = cy - Math.sin(innerStartAngle) * r0;
+			path.push(arc(r0, r0, 0, largeArcFlag(innerStartAngle - innerEndAngle), 1, innerArcToX, innerArcToY));
 		} else {
-			path.push(move(x, y));
+			path.push(move(cx, cy));
 		}
-		var lineToX = x + Math.cos(startAngleRadian) * r;
-		var lineToY = y - Math.sin(startAngleRadian) * r;
+		var outerGapAngle = r > 0 && gap2 > 0 ? Math.asin(gap2 / r) : 0;
+		var outerStartAngle = startAngle + outerGapAngle;
+		var outerEndAngle = endAngle - outerGapAngle;
+		var lineToX = cx + Math.cos(outerStartAngle) * r;
+		var lineToY = cy - Math.sin(outerStartAngle) * r;
 		path.push(line$1(lineToX, lineToY));
-		var arcToX = x + Math.cos(endAngleRadian) * r;
-		var arcToY = y - Math.sin(endAngleRadian) * r;
-		path.push(arc(r, r, 0, largeArc, 0, arcToX, arcToY));
+		var arcToX = cx + Math.cos(outerEndAngle) * r;
+		var arcToY = cy - Math.sin(outerEndAngle) * r;
+		path.push(arc(r, r, 0, largeArcFlag(outerEndAngle - outerStartAngle), 0, arcToX, arcToY));
 	}
 	path.push(z());
 	return path.join(" ");
 }
 PieChart.prototype.anchors = "0 1 1 0";
 PieChart.prototype.angle = 360;
+PieChart.prototype.startAngle = 0;
+PieChart.prototype.gap = 0;
 Widget.alias("pie-slice");
 var PieSlice = /*#__PURE__*/ (function (_Container) {
 	function PieSlice() {
@@ -783,7 +856,7 @@ var PieSlice = /*#__PURE__*/ (function (_Container) {
 		if (instance.colorMap && data.colorName) instance.colorMap.acknowledge(data.colorName);
 		instance.hoverSync = context.hoverSync;
 		if (instance.valid && data.active) {
-			instance.pie.acknowledge(data.stack, data.value);
+			instance.pie.acknowledge(data.stack, data.value, data.r, data.r0, this.percentageRadius);
 			_Container.prototype.explore.call(this, context, instance);
 		}
 	};
@@ -798,7 +871,7 @@ var PieSlice = /*#__PURE__*/ (function (_Container) {
 			if (instance.cache("colorIndex", data.colorIndex)) instance.markShouldUpdate(context);
 		}
 		if (instance.valid && data.active) {
-			var seg = pie.map(data.stack, data.value);
+			var seg = pie.map(data.stack, data.value, data.r, data.r0, this.percentageRadius);
 			if (
 				!segment ||
 				instance.shouldUpdate ||
@@ -887,6 +960,7 @@ var PieSlice = /*#__PURE__*/ (function (_Container) {
 				segment.startAngle,
 				segment.endAngle,
 				data.br,
+				segment.gap,
 			);
 			return /*#__PURE__*/ jsxs(
 				"g",
@@ -939,6 +1013,9 @@ function z() {
 function arc(rx, ry, xRotation, largeArc, sweep, x, y) {
 	return "A " + rx + " " + ry + " " + xRotation + " " + largeArc + " " + sweep + " " + x + " " + y;
 }
+function largeArcFlag(angle) {
+	return angle > Math.PI || angle < -Math.PI ? 1 : 0;
+}
 PieSlice.prototype.offset = 0;
 PieSlice.prototype.r0 = 0;
 PieSlice.prototype.r = 50;
@@ -951,6 +1028,7 @@ PieSlice.prototype.legendAction = "auto";
 PieSlice.prototype.legendShape = "circle";
 PieSlice.prototype.hoverChannel = "default";
 PieSlice.prototype.styled = true;
+PieSlice.prototype.br = 0;
 Widget.alias("pie-chart", PieChart);
 
 debug("The Pie class is deprecated. Please use PieChart instead.");
@@ -2718,6 +2796,172 @@ Swimlanes.prototype.vertical = false;
 Swimlanes.prototype.styled = true;
 BoundedObject.alias("swimlanes", Swimlanes);
 
+var RangeMarker = /*#__PURE__*/ (function (_BoundedObject) {
+	function RangeMarker() {
+		return _BoundedObject.apply(this, arguments) || this;
+	}
+	_inheritsLoose(RangeMarker, _BoundedObject);
+	var _proto = RangeMarker.prototype;
+	_proto.declareData = function declareData() {
+		var _BoundedObject$protot;
+		(_BoundedObject$protot = _BoundedObject.prototype.declareData).call.apply(
+			_BoundedObject$protot,
+			[this].concat(Array.prototype.slice.call(arguments), [
+				{
+					x: undefined,
+					y: undefined,
+					shape: undefined,
+					vertical: undefined,
+					size: undefined,
+					laneOffset: undefined,
+					lineStyle: {
+						structured: true,
+					},
+					lineClass: {
+						structured: true,
+					},
+					capSize: undefined,
+					inflate: undefined,
+				},
+			]),
+		);
+	};
+	_proto.init = function init() {
+		this.lineStyle = parseStyle(this.lineStyle);
+		_BoundedObject.prototype.init.call(this);
+	};
+	_proto.prepareData = function prepareData(context, instance) {
+		instance.axes = context.axes;
+		instance.xAxis = context.axes[this.xAxis];
+		instance.yAxis = context.axes[this.yAxis];
+		_BoundedObject.prototype.prepareData.call(this, context, instance);
+	};
+	_proto.explore = function explore(context, instance) {
+		var data = instance.data,
+			xAxis = instance.xAxis,
+			yAxis = instance.yAxis;
+		if (this.affectsAxes) {
+			if (xAxis && data.x != null) xAxis.acknowledge(data.x, 0, 0);
+			if (yAxis && data.y != null) yAxis.acknowledge(data.y, 0, 0);
+		}
+		_BoundedObject.prototype.explore.call(this, context, instance);
+	};
+	_proto.calculateBounds = function calculateBounds(context, instance) {
+		var data = instance.data,
+			xAxis = instance.xAxis,
+			yAxis = instance.yAxis;
+		var l, r, t, b;
+		if (data.x == null || data.y == null) {
+			return _BoundedObject.prototype.calculateBounds.call(this, context, instance);
+		}
+		if (!this.vertical) {
+			l = xAxis.map(data.x, data.laneOffset - data.size / 2) - data.inflate;
+			r = xAxis.map(data.x, data.laneOffset + data.size / 2) + data.inflate;
+			t = b = yAxis.map(data.y);
+			if (data.shape == "max") {
+				b += data.capSize;
+			} else if (data.shape == "min") {
+				t -= data.capSize;
+			}
+		} else {
+			l = r = xAxis.map(data.x);
+			t = yAxis.map(data.y, data.laneOffset - data.size / 2) + data.inflate;
+			b = yAxis.map(data.y, data.laneOffset + data.size / 2) - data.inflate;
+			if (data.shape == "max") {
+				l -= data.capSize;
+			} else if (data.shape == "min") {
+				r += data.capSize;
+			}
+		}
+		return new Rect({
+			l: l,
+			r: r,
+			t: t,
+			b: b,
+		});
+	};
+	_proto.prepare = function prepare(context, instance) {
+		_BoundedObject.prototype.prepare.call(this, context, instance);
+	};
+	_proto.render = function render(context, instance, key) {
+		var data = instance.data;
+		var CSS = this.CSS,
+			baseClass = this.baseClass;
+		var bounds = data.bounds,
+			shape = data.shape;
+		var path = "";
+		if (this.vertical) {
+			switch (shape) {
+				default:
+				case "line":
+					path += "M " + bounds.r + " " + bounds.t + " ";
+					path += "L " + bounds.r + " " + bounds.b;
+					break;
+				case "max":
+					path += "M " + bounds.l + " " + bounds.t + " ";
+					path += "L " + bounds.r + " " + bounds.t;
+					path += "L " + bounds.r + " " + bounds.b;
+					path += "L " + bounds.l + " " + bounds.b;
+					break;
+				case "min":
+					path += "M " + bounds.r + " " + bounds.t + " ";
+					path += "L " + bounds.l + " " + bounds.t;
+					path += "L " + bounds.l + " " + bounds.b;
+					path += "L " + bounds.r + " " + bounds.b;
+					break;
+			}
+		} else {
+			switch (shape) {
+				default:
+				case "line":
+					path += "M " + bounds.r + " " + bounds.t + " ";
+					path += "L " + bounds.l + " " + bounds.t;
+					break;
+				case "max":
+					path += "M " + bounds.l + " " + bounds.b + " ";
+					path += "L " + bounds.l + " " + bounds.t;
+					path += "L " + bounds.r + " " + bounds.t;
+					path += "L " + bounds.r + " " + bounds.b;
+					break;
+				case "min":
+					path += "M " + bounds.l + " " + bounds.t + " ";
+					path += "L " + bounds.l + " " + bounds.b;
+					path += "L " + bounds.r + " " + bounds.b;
+					path += "L " + bounds.r + " " + bounds.t;
+					break;
+			}
+		}
+		return /*#__PURE__*/ jsxs(
+			"g",
+			{
+				class: data.classNames,
+				style: data.style,
+				children: [
+					/*#__PURE__*/ jsx("path", {
+						d: path,
+						class: CSS.expand(CSS.element(baseClass, "path"), data.lineClass),
+						style: data.lineStyle,
+					}),
+					this.renderChildren(context, instance),
+				],
+			},
+			key,
+		);
+	};
+	return RangeMarker;
+})(BoundedObject);
+RangeMarker.prototype.baseClass = "rangemarker";
+RangeMarker.prototype.xAxis = "x";
+RangeMarker.prototype.yAxis = "y";
+RangeMarker.prototype.shape = "line";
+RangeMarker.prototype.vertical = false;
+RangeMarker.prototype.size = 1;
+RangeMarker.prototype.laneOffset = 0;
+RangeMarker.prototype.capSize = 5;
+RangeMarker.prototype.inflate = 0;
+RangeMarker.prototype.affectsAxes = true;
+Widget.alias("range-marker", RangeMarker);
+
 var LineGraph = /*#__PURE__*/ (function (_Widget) {
 	function LineGraph() {
 		return _Widget.apply(this, arguments) || this;
@@ -4968,6 +5212,7 @@ export {
 	PieSlice,
 	PointReducer,
 	Range,
+	RangeMarker,
 	ScatterGraph,
 	SnapPointFinder,
 	Swimlanes,