pristine-charts 0.1.0 → 0.1.2

package/dist/funnel-chart/index.cjs

@@ -0,0 +1,1725 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var d3 = require('d3');
+
+// src/funnel-chart/FunnelChart.tsx
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isPlaceholder.js
+function _isPlaceholder(a) {
+  return a != null && typeof a === "object" && a["@@functional/placeholder"] === true;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_curry1.js
+function _curry1(fn) {
+  return function f1(a) {
+    if (arguments.length === 0 || _isPlaceholder(a)) {
+      return f1;
+    } else {
+      return fn.apply(this, arguments);
+    }
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_curry2.js
+function _curry2(fn) {
+  return function f2(a, b) {
+    switch (arguments.length) {
+      case 0:
+        return f2;
+      case 1:
+        return _isPlaceholder(a) ? f2 : _curry1(function(_b) {
+          return fn(a, _b);
+        });
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function(_a) {
+          return fn(_a, b);
+        }) : _isPlaceholder(b) ? _curry1(function(_b) {
+          return fn(a, _b);
+        }) : fn(a, b);
+    }
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isArray.js
+var isArray_default = Array.isArray || function _isArray(val) {
+  return val != null && val.length >= 0 && Object.prototype.toString.call(val) === "[object Array]";
+};
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isTransformer.js
+function _isTransformer(obj) {
+  return obj != null && typeof obj["@@transducer/step"] === "function";
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_dispatchable.js
+function _dispatchable(methodNames, transducerCreator, fn) {
+  return function() {
+    if (arguments.length === 0) {
+      return fn();
+    }
+    var obj = arguments[arguments.length - 1];
+    if (!isArray_default(obj)) {
+      var idx = 0;
+      while (idx < methodNames.length) {
+        if (typeof obj[methodNames[idx]] === "function") {
+          return obj[methodNames[idx]].apply(obj, Array.prototype.slice.call(arguments, 0, -1));
+        }
+        idx += 1;
+      }
+      if (_isTransformer(obj)) {
+        var transducer = transducerCreator.apply(null, Array.prototype.slice.call(arguments, 0, -1));
+        return transducer(obj);
+      }
+    }
+    return fn.apply(this, arguments);
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_reduced.js
+function _reduced(x) {
+  return x && x["@@transducer/reduced"] ? x : {
+    "@@transducer/value": x,
+    "@@transducer/reduced": true
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_xfBase.js
+var xfBase_default = {
+  init: function() {
+    return this.xf["@@transducer/init"]();
+  },
+  result: function(result) {
+    return this.xf["@@transducer/result"](result);
+  }
+};
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_xall.js
+var XAll = /* @__PURE__ */ (function() {
+  function XAll2(f, xf) {
+    this.xf = xf;
+    this.f = f;
+    this.all = true;
+  }
+  XAll2.prototype["@@transducer/init"] = xfBase_default.init;
+  XAll2.prototype["@@transducer/result"] = function(result) {
+    if (this.all) {
+      result = this.xf["@@transducer/step"](result, true);
+    }
+    return this.xf["@@transducer/result"](result);
+  };
+  XAll2.prototype["@@transducer/step"] = function(result, input) {
+    if (!this.f(input)) {
+      this.all = false;
+      result = _reduced(this.xf["@@transducer/step"](result, false));
+    }
+    return result;
+  };
+  return XAll2;
+})();
+function _xall(f) {
+  return function(xf) {
+    return new XAll(f, xf);
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/all.js
+var all = /* @__PURE__ */ _curry2(/* @__PURE__ */ _dispatchable(["all"], _xall, function all2(fn, list) {
+  var idx = 0;
+  while (idx < list.length) {
+    if (!fn(list[idx])) {
+      return false;
+    }
+    idx += 1;
+  }
+  return true;
+}));
+var all_default = all;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_arity.js
+function _arity(n, fn) {
+  switch (n) {
+    case 0:
+      return function() {
+        return fn.apply(this, arguments);
+      };
+    case 1:
+      return function(a0) {
+        return fn.apply(this, arguments);
+      };
+    case 2:
+      return function(a0, a1) {
+        return fn.apply(this, arguments);
+      };
+    case 3:
+      return function(a0, a1, a2) {
+        return fn.apply(this, arguments);
+      };
+    case 4:
+      return function(a0, a1, a2, a3) {
+        return fn.apply(this, arguments);
+      };
+    case 5:
+      return function(a0, a1, a2, a3, a4) {
+        return fn.apply(this, arguments);
+      };
+    case 6:
+      return function(a0, a1, a2, a3, a4, a5) {
+        return fn.apply(this, arguments);
+      };
+    case 7:
+      return function(a0, a1, a2, a3, a4, a5, a6) {
+        return fn.apply(this, arguments);
+      };
+    case 8:
+      return function(a0, a1, a2, a3, a4, a5, a6, a7) {
+        return fn.apply(this, arguments);
+      };
+    case 9:
+      return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {
+        return fn.apply(this, arguments);
+      };
+    case 10:
+      return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+        return fn.apply(this, arguments);
+      };
+    default:
+      throw new Error("First argument to _arity must be a non-negative integer no greater than ten");
+  }
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_curryN.js
+function _curryN(length, received, fn) {
+  return function() {
+    var combined = [];
+    var argsIdx = 0;
+    var left = length;
+    var combinedIdx = 0;
+    var hasPlaceholder = false;
+    while (combinedIdx < received.length || argsIdx < arguments.length) {
+      var result;
+      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {
+        result = received[combinedIdx];
+      } else {
+        result = arguments[argsIdx];
+        argsIdx += 1;
+      }
+      combined[combinedIdx] = result;
+      if (!_isPlaceholder(result)) {
+        left -= 1;
+      } else {
+        hasPlaceholder = true;
+      }
+      combinedIdx += 1;
+    }
+    return !hasPlaceholder && left <= 0 ? fn.apply(this, combined) : _arity(Math.max(0, left), _curryN(length, combined, fn));
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/curryN.js
+var curryN = /* @__PURE__ */ _curry2(function curryN2(length, fn) {
+  if (length === 1) {
+    return _curry1(fn);
+  }
+  return _arity(length, _curryN(length, [], fn));
+});
+var curryN_default = curryN;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_arrayFromIterator.js
+function _arrayFromIterator(iter) {
+  var list = [];
+  var next;
+  while (!(next = iter.next()).done) {
+    list.push(next.value);
+  }
+  return list;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_includesWith.js
+function _includesWith(pred, x, list) {
+  var idx = 0;
+  var len = list.length;
+  while (idx < len) {
+    if (pred(x, list[idx])) {
+      return true;
+    }
+    idx += 1;
+  }
+  return false;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_functionName.js
+function _functionName(f) {
+  var match = String(f).match(/^function (\w*)/);
+  return match == null ? "" : match[1];
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_has.js
+function _has(prop3, obj) {
+  return Object.prototype.hasOwnProperty.call(obj, prop3);
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_objectIs.js
+function _objectIs(a, b) {
+  if (a === b) {
+    return a !== 0 || 1 / a === 1 / b;
+  } else {
+    return a !== a && b !== b;
+  }
+}
+var objectIs_default = typeof Object.is === "function" ? Object.is : _objectIs;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isArguments.js
+var toString = Object.prototype.toString;
+var _isArguments = /* @__PURE__ */ (function() {
+  return toString.call(arguments) === "[object Arguments]" ? function _isArguments2(x) {
+    return toString.call(x) === "[object Arguments]";
+  } : function _isArguments2(x) {
+    return _has("callee", x);
+  };
+})();
+var isArguments_default = _isArguments;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/keys.js
+var hasEnumBug = !/* @__PURE__ */ {
+  toString: null
+}.propertyIsEnumerable("toString");
+var nonEnumerableProps = ["constructor", "valueOf", "isPrototypeOf", "toString", "propertyIsEnumerable", "hasOwnProperty", "toLocaleString"];
+var hasArgsEnumBug = /* @__PURE__ */ (function() {
+  return arguments.propertyIsEnumerable("length");
+})();
+var contains = function contains2(list, item) {
+  var idx = 0;
+  while (idx < list.length) {
+    if (list[idx] === item) {
+      return true;
+    }
+    idx += 1;
+  }
+  return false;
+};
+var keys = typeof Object.keys === "function" && !hasArgsEnumBug ? /* @__PURE__ */ _curry1(function keys2(obj) {
+  return Object(obj) !== obj ? [] : Object.keys(obj);
+}) : /* @__PURE__ */ _curry1(function keys3(obj) {
+  if (Object(obj) !== obj) {
+    return [];
+  }
+  var prop3, nIdx;
+  var ks = [];
+  var checkArgsLength = hasArgsEnumBug && isArguments_default(obj);
+  for (prop3 in obj) {
+    if (_has(prop3, obj) && (!checkArgsLength || prop3 !== "length")) {
+      ks[ks.length] = prop3;
+    }
+  }
+  if (hasEnumBug) {
+    nIdx = nonEnumerableProps.length - 1;
+    while (nIdx >= 0) {
+      prop3 = nonEnumerableProps[nIdx];
+      if (_has(prop3, obj) && !contains(ks, prop3)) {
+        ks[ks.length] = prop3;
+      }
+      nIdx -= 1;
+    }
+  }
+  return ks;
+});
+var keys_default = keys;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/type.js
+var type = /* @__PURE__ */ _curry1(function type2(val) {
+  return val === null ? "Null" : val === void 0 ? "Undefined" : Object.prototype.toString.call(val).slice(8, -1);
+});
+var type_default = type;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_equals.js
+function _uniqContentEquals(aIterator, bIterator, stackA, stackB) {
+  var a = _arrayFromIterator(aIterator);
+  var b = _arrayFromIterator(bIterator);
+  function eq(_a, _b) {
+    return _equals(_a, _b, stackA.slice(), stackB.slice());
+  }
+  return !_includesWith(function(b2, aItem) {
+    return !_includesWith(eq, aItem, b2);
+  }, b, a);
+}
+function _equals(a, b, stackA, stackB) {
+  if (objectIs_default(a, b)) {
+    return true;
+  }
+  var typeA = type_default(a);
+  if (typeA !== type_default(b)) {
+    return false;
+  }
+  if (typeof a["fantasy-land/equals"] === "function" || typeof b["fantasy-land/equals"] === "function") {
+    return typeof a["fantasy-land/equals"] === "function" && a["fantasy-land/equals"](b) && typeof b["fantasy-land/equals"] === "function" && b["fantasy-land/equals"](a);
+  }
+  if (typeof a.equals === "function" || typeof b.equals === "function") {
+    return typeof a.equals === "function" && a.equals(b) && typeof b.equals === "function" && b.equals(a);
+  }
+  switch (typeA) {
+    case "Arguments":
+    case "Array":
+    case "Object":
+      if (typeof a.constructor === "function" && _functionName(a.constructor) === "Promise") {
+        return a === b;
+      }
+      break;
+    case "Boolean":
+    case "Number":
+    case "String":
+      if (!(typeof a === typeof b && objectIs_default(a.valueOf(), b.valueOf()))) {
+        return false;
+      }
+      break;
+    case "Date":
+      if (!objectIs_default(a.valueOf(), b.valueOf())) {
+        return false;
+      }
+      break;
+    case "Error":
+      return a.name === b.name && a.message === b.message;
+    case "RegExp":
+      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {
+        return false;
+      }
+      break;
+  }
+  var idx = stackA.length - 1;
+  while (idx >= 0) {
+    if (stackA[idx] === a) {
+      return stackB[idx] === b;
+    }
+    idx -= 1;
+  }
+  switch (typeA) {
+    case "Map":
+      if (a.size !== b.size) {
+        return false;
+      }
+      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));
+    case "Set":
+      if (a.size !== b.size) {
+        return false;
+      }
+      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));
+    case "Arguments":
+    case "Array":
+    case "Object":
+    case "Boolean":
+    case "Number":
+    case "String":
+    case "Date":
+    case "Error":
+    case "RegExp":
+    case "Int8Array":
+    case "Uint8Array":
+    case "Uint8ClampedArray":
+    case "Int16Array":
+    case "Uint16Array":
+    case "Int32Array":
+    case "Uint32Array":
+    case "Float32Array":
+    case "Float64Array":
+    case "ArrayBuffer":
+      break;
+    default:
+      return false;
+  }
+  var keysA = keys_default(a);
+  if (keysA.length !== keys_default(b).length) {
+    return false;
+  }
+  var extendedStackA = stackA.concat([a]);
+  var extendedStackB = stackB.concat([b]);
+  idx = keysA.length - 1;
+  while (idx >= 0) {
+    var key = keysA[idx];
+    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {
+      return false;
+    }
+    idx -= 1;
+  }
+  return true;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/equals.js
+var equals = /* @__PURE__ */ _curry2(function equals2(a, b) {
+  return _equals(a, b, [], []);
+});
+var equals_default = equals;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_indexOf.js
+function _indexOf(list, a, idx) {
+  var inf, item;
+  if (typeof list.indexOf === "function") {
+    switch (typeof a) {
+      case "number":
+        if (a === 0) {
+          inf = 1 / a;
+          while (idx < list.length) {
+            item = list[idx];
+            if (item === 0 && 1 / item === inf) {
+              return idx;
+            }
+            idx += 1;
+          }
+          return -1;
+        } else if (a !== a) {
+          while (idx < list.length) {
+            item = list[idx];
+            if (typeof item === "number" && item !== item) {
+              return idx;
+            }
+            idx += 1;
+          }
+          return -1;
+        }
+        return list.indexOf(a, idx);
+      // all these types can utilise Set
+      case "string":
+      case "boolean":
+      case "function":
+      case "undefined":
+        return list.indexOf(a, idx);
+      case "object":
+        if (a === null) {
+          return list.indexOf(a, idx);
+        }
+    }
+  }
+  while (idx < list.length) {
+    if (equals_default(list[idx], a)) {
+      return idx;
+    }
+    idx += 1;
+  }
+  return -1;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_includes.js
+function _includes(a, list) {
+  return _indexOf(list, a, 0) >= 0;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_map.js
+function _map(fn, functor) {
+  var idx = 0;
+  var len = functor.length;
+  var result = Array(len);
+  while (idx < len) {
+    result[idx] = fn(functor[idx]);
+    idx += 1;
+  }
+  return result;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_quote.js
+function _quote(s) {
+  var escaped = s.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\f/g, "\\f").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\v/g, "\\v").replace(/\0/g, "\\0");
+  return '"' + escaped.replace(/"/g, '\\"') + '"';
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_toISOString.js
+var pad = function pad2(n) {
+  return (n < 10 ? "0" : "") + n;
+};
+var _toISOString = typeof Date.prototype.toISOString === "function" ? function _toISOString2(d) {
+  return d.toISOString();
+} : function _toISOString3(d) {
+  return d.getUTCFullYear() + "-" + pad(d.getUTCMonth() + 1) + "-" + pad(d.getUTCDate()) + "T" + pad(d.getUTCHours()) + ":" + pad(d.getUTCMinutes()) + ":" + pad(d.getUTCSeconds()) + "." + (d.getUTCMilliseconds() / 1e3).toFixed(3).slice(2, 5) + "Z";
+};
+var toISOString_default = _toISOString;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_complement.js
+function _complement(f) {
+  return function() {
+    return !f.apply(this, arguments);
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_arrayReduce.js
+function _arrayReduce(reducer, acc, list) {
+  var index = 0;
+  var length = list.length;
+  while (index < length) {
+    acc = reducer(acc, list[index]);
+    index += 1;
+  }
+  return acc;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_filter.js
+function _filter(fn, list) {
+  var idx = 0;
+  var len = list.length;
+  var result = [];
+  while (idx < len) {
+    if (fn(list[idx])) {
+      result[result.length] = list[idx];
+    }
+    idx += 1;
+  }
+  return result;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isObject.js
+function _isObject(x) {
+  return Object.prototype.toString.call(x) === "[object Object]";
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_xfilter.js
+var XFilter = /* @__PURE__ */ (function() {
+  function XFilter2(f, xf) {
+    this.xf = xf;
+    this.f = f;
+  }
+  XFilter2.prototype["@@transducer/init"] = xfBase_default.init;
+  XFilter2.prototype["@@transducer/result"] = xfBase_default.result;
+  XFilter2.prototype["@@transducer/step"] = function(result, input) {
+    return this.f(input) ? this.xf["@@transducer/step"](result, input) : result;
+  };
+  return XFilter2;
+})();
+function _xfilter(f) {
+  return function(xf) {
+    return new XFilter(f, xf);
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/filter.js
+var filter = /* @__PURE__ */ _curry2(/* @__PURE__ */ _dispatchable(["fantasy-land/filter", "filter"], _xfilter, function(pred, filterable) {
+  return _isObject(filterable) ? _arrayReduce(function(acc, key) {
+    if (pred(filterable[key])) {
+      acc[key] = filterable[key];
+    }
+    return acc;
+  }, {}, keys_default(filterable)) : (
+    // else
+    _filter(pred, filterable)
+  );
+}));
+var filter_default = filter;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/reject.js
+var reject = /* @__PURE__ */ _curry2(function reject2(pred, filterable) {
+  return filter_default(_complement(pred), filterable);
+});
+var reject_default = reject;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_toString.js
+function _toString(x, seen) {
+  var recur = function recur2(y) {
+    var xs = seen.concat([x]);
+    return _includes(y, xs) ? "<Circular>" : _toString(y, xs);
+  };
+  var mapPairs = function(obj, keys4) {
+    return _map(function(k) {
+      return _quote(k) + ": " + recur(obj[k]);
+    }, keys4.slice().sort());
+  };
+  switch (Object.prototype.toString.call(x)) {
+    case "[object Arguments]":
+      return "(function() { return arguments; }(" + _map(recur, x).join(", ") + "))";
+    case "[object Array]":
+      return "[" + _map(recur, x).concat(mapPairs(x, reject_default(function(k) {
+        return /^\d+$/.test(k);
+      }, keys_default(x)))).join(", ") + "]";
+    case "[object Boolean]":
+      return typeof x === "object" ? "new Boolean(" + recur(x.valueOf()) + ")" : x.toString();
+    case "[object Date]":
+      return "new Date(" + (isNaN(x.valueOf()) ? recur(NaN) : _quote(toISOString_default(x))) + ")";
+    case "[object Map]":
+      return "new Map(" + recur(Array.from(x)) + ")";
+    case "[object Null]":
+      return "null";
+    case "[object Number]":
+      return typeof x === "object" ? "new Number(" + recur(x.valueOf()) + ")" : 1 / x === -Infinity ? "-0" : x.toString(10);
+    case "[object Set]":
+      return "new Set(" + recur(Array.from(x).sort()) + ")";
+    case "[object String]":
+      return typeof x === "object" ? "new String(" + recur(x.valueOf()) + ")" : _quote(x);
+    case "[object Undefined]":
+      return "undefined";
+    default:
+      if (typeof x.toString === "function") {
+        var repr = x.toString();
+        if (repr !== "[object Object]") {
+          return repr;
+        }
+      }
+      return "{" + mapPairs(x, keys_default(x)).join(", ") + "}";
+  }
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/toString.js
+var toString2 = /* @__PURE__ */ _curry1(function toString3(val) {
+  return _toString(val, []);
+});
+var toString_default = toString2;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/max.js
+var max = /* @__PURE__ */ _curry2(function max2(a, b) {
+  if (a === b) {
+    return b;
+  }
+  function safeMax(x, y) {
+    if (x > y !== y > x) {
+      return y > x ? y : x;
+    }
+    return void 0;
+  }
+  var maxByValue = safeMax(a, b);
+  if (maxByValue !== void 0) {
+    return maxByValue;
+  }
+  var maxByType = safeMax(typeof a, typeof b);
+  if (maxByType !== void 0) {
+    return maxByType === typeof a ? a : b;
+  }
+  var stringA = toString_default(a);
+  var maxByStringValue = safeMax(stringA, toString_default(b));
+  if (maxByStringValue !== void 0) {
+    return maxByStringValue === stringA ? a : b;
+  }
+  return b;
+});
+var max_default = max;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_xmap.js
+var XMap = /* @__PURE__ */ (function() {
+  function XMap2(f, xf) {
+    this.xf = xf;
+    this.f = f;
+  }
+  XMap2.prototype["@@transducer/init"] = xfBase_default.init;
+  XMap2.prototype["@@transducer/result"] = xfBase_default.result;
+  XMap2.prototype["@@transducer/step"] = function(result, input) {
+    return this.xf["@@transducer/step"](result, this.f(input));
+  };
+  return XMap2;
+})();
+var _xmap = function _xmap2(f) {
+  return function(xf) {
+    return new XMap(f, xf);
+  };
+};
+var xmap_default = _xmap;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/map.js
+var map = /* @__PURE__ */ _curry2(/* @__PURE__ */ _dispatchable(["fantasy-land/map", "map"], xmap_default, function map2(fn, functor) {
+  switch (Object.prototype.toString.call(functor)) {
+    case "[object Function]":
+      return curryN_default(functor.length, function() {
+        return fn.call(this, functor.apply(this, arguments));
+      });
+    case "[object Object]":
+      return _arrayReduce(function(acc, key) {
+        acc[key] = fn(functor[key]);
+        return acc;
+      }, {}, keys_default(functor));
+    default:
+      return _map(fn, functor);
+  }
+}));
+var map_default = map;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isInteger.js
+var isInteger_default = Number.isInteger || function _isInteger(n) {
+  return n << 0 === n;
+};
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isString.js
+function _isString(x) {
+  return Object.prototype.toString.call(x) === "[object String]";
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_nth.js
+function _nth(offset, list) {
+  var idx = offset < 0 ? list.length + offset : offset;
+  return _isString(list) ? list.charAt(idx) : list[idx];
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/prop.js
+var prop = /* @__PURE__ */ _curry2(function prop2(p, obj) {
+  if (obj == null) {
+    return;
+  }
+  return isInteger_default(p) ? _nth(p, obj) : obj[p];
+});
+var prop_default = prop;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/pluck.js
+var pluck = /* @__PURE__ */ _curry2(function pluck2(p, list) {
+  return map_default(prop_default(p), list);
+});
+var pluck_default = pluck;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_curry3.js
+function _curry3(fn) {
+  return function f3(a, b, c) {
+    switch (arguments.length) {
+      case 0:
+        return f3;
+      case 1:
+        return _isPlaceholder(a) ? f3 : _curry2(function(_b, _c) {
+          return fn(a, _b, _c);
+        });
+      case 2:
+        return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function(_a, _c) {
+          return fn(_a, b, _c);
+        }) : _isPlaceholder(b) ? _curry2(function(_b, _c) {
+          return fn(a, _b, _c);
+        }) : _curry1(function(_c) {
+          return fn(a, b, _c);
+        });
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function(_a, _b) {
+          return fn(_a, _b, c);
+        }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function(_a, _c) {
+          return fn(_a, b, _c);
+        }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function(_b, _c) {
+          return fn(a, _b, _c);
+        }) : _isPlaceholder(a) ? _curry1(function(_a) {
+          return fn(_a, b, c);
+        }) : _isPlaceholder(b) ? _curry1(function(_b) {
+          return fn(a, _b, c);
+        }) : _isPlaceholder(c) ? _curry1(function(_c) {
+          return fn(a, b, _c);
+        }) : fn(a, b, c);
+    }
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isArrayLike.js
+var _isArrayLike = /* @__PURE__ */ _curry1(function isArrayLike(x) {
+  if (isArray_default(x)) {
+    return true;
+  }
+  if (!x) {
+    return false;
+  }
+  if (typeof x !== "object") {
+    return false;
+  }
+  if (_isString(x)) {
+    return false;
+  }
+  if (x.length === 0) {
+    return true;
+  }
+  if (x.length > 0) {
+    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
+  }
+  return false;
+});
+var isArrayLike_default = _isArrayLike;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_createReduce.js
+var symIterator = typeof Symbol !== "undefined" ? Symbol.iterator : "@@iterator";
+function _createReduce(arrayReduce, methodReduce, iterableReduce) {
+  return function _reduce2(xf, acc, list) {
+    if (isArrayLike_default(list)) {
+      return arrayReduce(xf, acc, list);
+    }
+    if (list == null) {
+      return acc;
+    }
+    if (typeof list["fantasy-land/reduce"] === "function") {
+      return methodReduce(xf, acc, list, "fantasy-land/reduce");
+    }
+    if (list[symIterator] != null) {
+      return iterableReduce(xf, acc, list[symIterator]());
+    }
+    if (typeof list.next === "function") {
+      return iterableReduce(xf, acc, list);
+    }
+    if (typeof list.reduce === "function") {
+      return methodReduce(xf, acc, list, "reduce");
+    }
+    throw new TypeError("reduce: list must be array or iterable");
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_xArrayReduce.js
+function _xArrayReduce(xf, acc, list) {
+  var idx = 0;
+  var len = list.length;
+  while (idx < len) {
+    acc = xf["@@transducer/step"](acc, list[idx]);
+    if (acc && acc["@@transducer/reduced"]) {
+      acc = acc["@@transducer/value"];
+      break;
+    }
+    idx += 1;
+  }
+  return xf["@@transducer/result"](acc);
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/bind.js
+var bind = /* @__PURE__ */ _curry2(function bind2(fn, thisObj) {
+  return _arity(fn.length, function() {
+    return fn.apply(thisObj, arguments);
+  });
+});
+var bind_default = bind;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_xReduce.js
+function _xIterableReduce(xf, acc, iter) {
+  var step = iter.next();
+  while (!step.done) {
+    acc = xf["@@transducer/step"](acc, step.value);
+    if (acc && acc["@@transducer/reduced"]) {
+      acc = acc["@@transducer/value"];
+      break;
+    }
+    step = iter.next();
+  }
+  return xf["@@transducer/result"](acc);
+}
+function _xMethodReduce(xf, acc, obj, methodName) {
+  return xf["@@transducer/result"](obj[methodName](bind_default(xf["@@transducer/step"], xf), acc));
+}
+var _xReduce = /* @__PURE__ */ _createReduce(_xArrayReduce, _xMethodReduce, _xIterableReduce);
+var xReduce_default = _xReduce;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_xwrap.js
+var XWrap = /* @__PURE__ */ (function() {
+  function XWrap2(fn) {
+    this.f = fn;
+  }
+  XWrap2.prototype["@@transducer/init"] = function() {
+    throw new Error("init not implemented on XWrap");
+  };
+  XWrap2.prototype["@@transducer/result"] = function(acc) {
+    return acc;
+  };
+  XWrap2.prototype["@@transducer/step"] = function(acc, x) {
+    return this.f(acc, x);
+  };
+  return XWrap2;
+})();
+function _xwrap(fn) {
+  return new XWrap(fn);
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/reduce.js
+var reduce = /* @__PURE__ */ _curry3(function(xf, acc, list) {
+  return xReduce_default(typeof xf === "function" ? _xwrap(xf) : xf, acc, list);
+});
+var reduce_default = reduce;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/allPass.js
+var allPass = /* @__PURE__ */ _curry1(function allPass2(preds) {
+  return curryN_default(reduce_default(max_default, 0, pluck_default("length", preds)), function() {
+    var idx = 0;
+    var len = preds.length;
+    while (idx < len) {
+      if (!preds[idx].apply(this, arguments)) {
+        return false;
+      }
+      idx += 1;
+    }
+    return true;
+  });
+});
+var allPass_default = allPass;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/always.js
+var always = /* @__PURE__ */ _curry1(function always2(val) {
+  return function() {
+    return val;
+  };
+});
+var always_default = always;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_concat.js
+function _concat(set1, set2) {
+  set1 = set1 || [];
+  set2 = set2 || [];
+  var idx;
+  var len1 = set1.length;
+  var len2 = set2.length;
+  var result = [];
+  idx = 0;
+  while (idx < len1) {
+    result[result.length] = set1[idx];
+    idx += 1;
+  }
+  idx = 0;
+  while (idx < len2) {
+    result[result.length] = set2[idx];
+    idx += 1;
+  }
+  return result;
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_reduce.js
+function _iterableReduce(reducer, acc, iter) {
+  var step = iter.next();
+  while (!step.done) {
+    acc = reducer(acc, step.value);
+    step = iter.next();
+  }
+  return acc;
+}
+function _methodReduce(reducer, acc, obj, methodName) {
+  return obj[methodName](reducer, acc);
+}
+var _reduce = /* @__PURE__ */ _createReduce(_arrayReduce, _methodReduce, _iterableReduce);
+var reduce_default2 = _reduce;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/ap.js
+var ap = /* @__PURE__ */ _curry2(function ap2(applyF, applyX) {
+  return typeof applyX["fantasy-land/ap"] === "function" ? applyX["fantasy-land/ap"](applyF) : typeof applyF.ap === "function" ? applyF.ap(applyX) : typeof applyF === "function" ? function(x) {
+    return applyF(x)(applyX(x));
+  } : reduce_default2(function(acc, f) {
+    return _concat(acc, map_default(f, applyX));
+  }, [], applyF);
+});
+var ap_default = ap;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/liftN.js
+var liftN = /* @__PURE__ */ _curry2(function liftN2(arity, fn) {
+  var lifted = curryN_default(arity, fn);
+  return curryN_default(arity, function() {
+    return _arrayReduce(ap_default, map_default(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));
+  });
+});
+var liftN_default = liftN;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/lift.js
+var lift = /* @__PURE__ */ _curry1(function lift2(fn) {
+  return liftN_default(fn.length, fn);
+});
+var lift_default = lift;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/not.js
+var not = /* @__PURE__ */ _curry1(function not2(a) {
+  return !a;
+});
+var not_default = not;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/complement.js
+var complement = /* @__PURE__ */ lift_default(not_default);
+var complement_default = complement;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/cond.js
+var cond = /* @__PURE__ */ _curry1(function cond2(pairs) {
+  var arity = reduce_default(max_default, 0, map_default(function(pair) {
+    return pair[0].length;
+  }, pairs));
+  return _arity(arity, function() {
+    var idx = 0;
+    while (idx < pairs.length) {
+      if (pairs[idx][0].apply(this, arguments)) {
+        return pairs[idx][1].apply(this, arguments);
+      }
+      idx += 1;
+    }
+  });
+});
+var cond_default = cond;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/defaultTo.js
+var defaultTo = /* @__PURE__ */ _curry2(function defaultTo2(d, v) {
+  return v == null || v !== v ? d : v;
+});
+var defaultTo_default = defaultTo;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_xfindIndex.js
+var XFindIndex = /* @__PURE__ */ (function() {
+  function XFindIndex2(f, xf) {
+    this.xf = xf;
+    this.f = f;
+    this.idx = -1;
+    this.found = false;
+  }
+  XFindIndex2.prototype["@@transducer/init"] = xfBase_default.init;
+  XFindIndex2.prototype["@@transducer/result"] = function(result) {
+    if (!this.found) {
+      result = this.xf["@@transducer/step"](result, -1);
+    }
+    return this.xf["@@transducer/result"](result);
+  };
+  XFindIndex2.prototype["@@transducer/step"] = function(result, input) {
+    this.idx += 1;
+    if (this.f(input)) {
+      this.found = true;
+      result = _reduced(this.xf["@@transducer/step"](result, this.idx));
+    }
+    return result;
+  };
+  return XFindIndex2;
+})();
+function _xfindIndex(f) {
+  return function(xf) {
+    return new XFindIndex(f, xf);
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/findIndex.js
+var findIndex = /* @__PURE__ */ _curry2(/* @__PURE__ */ _dispatchable([], _xfindIndex, function findIndex2(fn, list) {
+  var idx = 0;
+  var len = list.length;
+  while (idx < len) {
+    if (fn(list[idx])) {
+      return idx;
+    }
+    idx += 1;
+  }
+  return -1;
+}));
+var findIndex_default = findIndex;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/ifElse.js
+var ifElse = /* @__PURE__ */ _curry3(function ifElse2(condition, onTrue, onFalse) {
+  return curryN_default(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {
+    return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);
+  });
+});
+var ifElse_default = ifElse;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/isNil.js
+var isNil = /* @__PURE__ */ _curry1(function isNil2(x) {
+  return x == null;
+});
+var isNil_default = isNil;
+
+// src/shared/className.ts
+var isPresentClassName = (value) => value.trim().length > 0;
+var classNames = (values) => filter_default(isPresentClassName, [...values]).join(" ");
+
+// src/shared/option.ts
+var none = { status: "none" };
+function some(value) {
+  return { status: "some", value };
+}
+var isSome = (option) => option.status === "some";
+var fromNullable = (value) => ifElse_default(
+  isNil_default,
+  always_default(none),
+  some
+)(value);
+function matchOption(option, matcher) {
+  return ifElse_default(
+    isSome,
+    (someOption) => matcher.some(someOption.value),
+    matcher.none
+  )(option);
+}
+
+// src/shared/number.ts
+var isNumber = (value) => typeof value === "number";
+var withNumberDefault = (fallback) => (value) => matchOption(fromNullable(value), {
+  none: () => fallback,
+  some: (resolvedValue) => ifElse_default(
+    isNumber,
+    (numberValue) => defaultTo_default(fallback, numberValue),
+    always_default(fallback)
+  )(resolvedValue)
+});
+
+// src/shared/result.ts
+function ok(value) {
+  return { status: "ok", value };
+}
+function err(error) {
+  return { status: "error", error };
+}
+var isOk = (result) => result.status === "ok";
+var andThenResult = (transform) => (result) => matchResult(result, {
+  error: err,
+  ok: transform
+});
+var mapResult = (transform) => (result) => andThenResult((value) => ok(transform(value)))(result);
+function matchResult(result, matcher) {
+  return ifElse_default(
+    isOk,
+    (okResult) => matcher.ok(okResult.value),
+    (errorResult) => matcher.error(errorResult.error)
+  )(result);
+}
+var renderDetails = (details) => matchOption(details, {
+  none: () => null,
+  some: (value) => /* @__PURE__ */ jsxRuntime.jsx("p", { className: "pristine-chart-error__details", children: value })
+});
+function ChartError({
+  title,
+  message,
+  details,
+  className,
+  role
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames(["pristine-chart-error", className]), role, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "pristine-chart-error__title", children: title }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "pristine-chart-error__message", children: message }),
+    renderDetails(details)
+  ] });
+}
+
+// src/funnel-chart/FunnelChart.domain.ts
+var MINIMUM_STAGE_COUNT = 2;
+var funnelChartRules = {
+  insufficientStages: () => ({
+    type: "InsufficientStages",
+    message: "A funnel chart needs at least two stages.",
+    details: none
+  }),
+  invalidStageValue: (stage, value) => ({
+    type: "InvalidStageValue",
+    message: "Every funnel chart stage value must be a non-negative finite number.",
+    details: some(`Invalid value for stage ${stage}: ${String(value)}.`)
+  }),
+  monotonicDecreaseViolation: (stage, previousStage) => ({
+    type: "MonotonicDecreaseViolation",
+    message: "Funnel chart stage values must not increase as the funnel progresses.",
+    details: some(`${stage} is greater than previous stage ${previousStage}.`)
+  }),
+  emptyStageName: (index) => ({
+    type: "EmptyStageName",
+    message: "Every funnel chart stage needs a non-empty name.",
+    details: some(`Empty stage at index ${String(index)}.`)
+  }),
+  duplicateStageName: (stage) => ({
+    type: "DuplicateStageName",
+    message: "Funnel chart stage names must be unique.",
+    details: some(`Duplicate stage: ${stage}.`)
+  }),
+  zeroInitialValue: () => ({
+    type: "ZeroInitialValue",
+    message: "A funnel chart must start with a value greater than zero.",
+    details: none
+  })
+};
+var isFiniteNumber = (value) => allPass_default([
+  (candidate) => typeof candidate === "number",
+  (candidate) => Number.isFinite(candidate)
+])(value);
+var isNonNegativeFiniteNumber = (value) => allPass_default([
+  isFiniteNumber,
+  (candidate) => Number(candidate) >= 0
+])(value);
+var isNonEmptyString = (value) => value.trim().length > 0;
+var hasEnoughStages = (data) => data.length >= MINIMUM_STAGE_COUNT;
+var getStages = (data) => map_default(prop_default("stage"), [...data]);
+var getValues = (data) => map_default(prop_default("value"), [...data]);
+var hasOnlyNamedStages = (data) => all_default(isNonEmptyString, getStages(data));
+var findEmptyStageIndex = (data) => findIndex_default(complement_default(isNonEmptyString), getStages(data));
+var hasOnlyValidValues = (data) => all_default(isNonNegativeFiniteNumber, getValues(data));
+var findInvalidValueStage = (data) => defaultTo_default(
+  { stage: "unknown stage", value: void 0 },
+  data.find((datum) => complement_default(isNonNegativeFiniteNumber)(datum.value))
+);
+var hasUniqueStages = (data) => {
+  const stages = getStages(data);
+  return stages.length === new Set(stages).size;
+};
+var findDuplicateStage = (data) => {
+  const stages = getStages(data);
+  return defaultTo_default(
+    "unknown stage",
+    stages.find((stage, index) => stages.indexOf(stage) !== index)
+  );
+};
+var firstStageValueIsPositive = (data) => data[0].value > 0;
+var toStagePair = (data) => (rightStage, index) => [data[index], rightStage];
+var getStagePairs = (data) => data.slice(1).map(toStagePair(data));
+var isMonotonicallyNonIncreasing = ([previous, current]) => current.value <= previous.value;
+var hasMonotonicDecrease = (data) => all_default(isMonotonicallyNonIncreasing, getStagePairs(data));
+var firstStagePair = (data) => [data[0], data[1]];
+var findMonotonicViolation = (data) => defaultTo_default(
+  firstStagePair(data),
+  getStagePairs(data).find(complement_default(isMonotonicallyNonIncreasing))
+);
+var datasetValidators = [
+  [complement_default(hasEnoughStages), () => err(funnelChartRules.insufficientStages())],
+  [
+    complement_default(hasOnlyNamedStages),
+    (candidate) => err(funnelChartRules.emptyStageName(findEmptyStageIndex(candidate)))
+  ],
+  [
+    complement_default(hasOnlyValidValues),
+    (candidate) => {
+      const invalidStage = findInvalidValueStage(candidate);
+      return err(funnelChartRules.invalidStageValue(invalidStage.stage, invalidStage.value));
+    }
+  ],
+  [
+    complement_default(hasUniqueStages),
+    (candidate) => err(funnelChartRules.duplicateStageName(findDuplicateStage(candidate)))
+  ],
+  [complement_default(firstStageValueIsPositive), () => err(funnelChartRules.zeroInitialValue())],
+  [
+    complement_default(hasMonotonicDecrease),
+    (candidate) => {
+      const [previousStage, stage] = findMonotonicViolation(candidate);
+      return err(funnelChartRules.monotonicDecreaseViolation(stage.stage, previousStage.stage));
+    }
+  ],
+  [always_default(true), (candidate) => ok(candidate)]
+];
+var validateFunnelChartInput = (input) => cond_default(datasetValidators)(input.data);
+var toDropOff = (previous, current) => previous.value - current.value;
+var previousStageIsZero = (previous) => previous.value === 0;
+var toDropOffRate = (previous, dropOff) => ifElse_default(
+  previousStageIsZero,
+  always_default(0),
+  (candidate) => dropOff / candidate.value
+)(previous);
+var toConversionRate = (previous, current) => ifElse_default(
+  previousStageIsZero,
+  always_default(1),
+  (candidate) => current.value / candidate.value
+)(previous);
+var toFunnelStage = (data) => (datum, index) => {
+  return matchOption(fromNullable(data[index - 1]), {
+    none: () => ({
+      ...datum,
+      index,
+      dropOff: none,
+      dropOffRate: none,
+      conversionRate: none
+    }),
+    some: (previousStage) => {
+      const dropOff = toDropOff(previousStage, datum);
+      return {
+        ...datum,
+        index,
+        dropOff: some(dropOff),
+        dropOffRate: some(toDropOffRate(previousStage, dropOff)),
+        conversionRate: some(toConversionRate(previousStage, datum))
+      };
+    }
+  });
+};
+var computeFunnelStages = (data) => data.map(toFunnelStage(data));
+function computeFunnelChart(input) {
+  return mapResult(
+    computeFunnelStages
+  )(validateFunnelChartInput(input));
+}
+var FUNNEL_CHART_MARGIN = {
+  top: 22,
+  right: 132,
+  bottom: 22,
+  left: 120
+};
+var STAGE_GAP = 4;
+var getMaximumValue = (stages) => withNumberDefault(0)(d3.max(map_default(prop_default("value"), [...stages])));
+var isZero = (value) => value === 0;
+var toScaledWidth = (plotWidth, maximumValue) => (value) => ifElse_default(
+  isZero,
+  always_default(0),
+  (candidate) => value / candidate * plotWidth
+)(maximumValue);
+var toPath = (centerX, y, height, topWidth, bottomWidth) => {
+  const topLeft = centerX - topWidth / 2;
+  const topRight = centerX + topWidth / 2;
+  const bottomLeft = centerX - bottomWidth / 2;
+  const bottomRight = centerX + bottomWidth / 2;
+  return `M ${topLeft} ${y} L ${topRight} ${y} L ${bottomRight} ${y + height} L ${bottomLeft} ${y + height} Z`;
+};
+var getNextStageValue = (stages, stage) => matchOption(fromNullable(stages[stage.index + 1]), {
+  none: () => stage.value,
+  some: (nextStage) => nextStage.value
+});
+var buildFunnelChartModel = (stages, width, height) => {
+  const plotLeft = FUNNEL_CHART_MARGIN.left;
+  const plotRight = width - FUNNEL_CHART_MARGIN.right;
+  const plotTop = FUNNEL_CHART_MARGIN.top;
+  const plotBottom = height - FUNNEL_CHART_MARGIN.bottom;
+  const plotWidth = plotRight - plotLeft;
+  const centerX = plotLeft + plotWidth / 2;
+  const totalGap = Math.max(0, stages.length - 1) * STAGE_GAP;
+  const stageHeight = (plotBottom - plotTop - totalGap) / stages.length;
+  const maximumValue = getMaximumValue(stages);
+  const scaledWidth = toScaledWidth(plotWidth, maximumValue);
+  const toRenderedStage = (stage) => {
+    const y = plotTop + stage.index * (stageHeight + STAGE_GAP);
+    const topWidth = scaledWidth(stage.value);
+    const bottomWidth = scaledWidth(getNextStageValue(stages, stage));
+    const stageWidth = Math.max(topWidth, bottomWidth);
+    return {
+      ...stage,
+      x: centerX - stageWidth / 2,
+      y,
+      width: stageWidth,
+      height: stageHeight,
+      centerX,
+      centerY: y + stageHeight / 2,
+      path: toPath(centerX, y, stageHeight, topWidth, bottomWidth),
+      hitAreaX: plotLeft,
+      hitAreaWidth: plotWidth,
+      labelX: plotLeft - 12,
+      valueX: plotRight + 12
+    };
+  };
+  return {
+    stages: map_default(toRenderedStage, [...stages]),
+    plotLeft,
+    plotRight,
+    plotTop,
+    plotBottom
+  };
+};
+function FunnelChartCaption({ caption }) {
+  return matchOption(caption, {
+    none: () => null,
+    some: (text) => /* @__PURE__ */ jsxRuntime.jsx("figcaption", { className: "pristine-funnel-chart__caption", children: text })
+  });
+}
+function FunnelChartSegment({ stage }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { className: "pristine-funnel-chart__segment", d: stage.path }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "rect",
+      {
+        className: "pristine-funnel-chart__hit-area",
+        x: stage.hitAreaX,
+        y: stage.y,
+        width: stage.hitAreaWidth,
+        height: stage.height
+      }
+    )
+  ] });
+}
+function FunnelChartStageLabel({ stage }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "text",
+    {
+      className: "pristine-funnel-chart__label",
+      x: stage.labelX,
+      y: stage.centerY,
+      textAnchor: "end",
+      children: stage.stage
+    }
+  );
+}
+function FunnelChartValueLabel({
+  stage,
+  formatValue,
+  formatPercentage
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "text",
+    {
+      className: "pristine-funnel-chart__value",
+      x: stage.valueX,
+      y: stage.centerY - 5,
+      textAnchor: "start",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("tspan", { x: stage.valueX, children: formatValue(stage.value) }),
+        matchOption(stage.conversionRate, {
+          none: () => null,
+          some: (conversionRate) => /* @__PURE__ */ jsxRuntime.jsx(
+            "tspan",
+            {
+              className: "pristine-funnel-chart__conversion",
+              x: stage.valueX,
+              dy: 14,
+              children: formatPercentage(conversionRate)
+            }
+          )
+        })
+      ]
+    }
+  );
+}
+var getAccessibleLabel = (stage, formatValue, formatPercentage) => matchOption(stage.dropOff, {
+  none: () => `${stage.stage}: ${formatValue(stage.value)}`,
+  some: (dropOff) => `${stage.stage}: ${formatValue(stage.value)}, drop-off ${formatValue(dropOff)}, conversion ${matchOption(
+    stage.conversionRate,
+    {
+      none: () => "not available",
+      some: formatPercentage
+    }
+  )}`
+});
+function FunnelChartStage({
+  active,
+  stage,
+  formatValue,
+  formatPercentage,
+  onActivate,
+  onDeactivate,
+  showValues
+}) {
+  const activeClassName = ifElse_default(
+    always_default(active),
+    always_default("pristine-funnel-chart__stage--active"),
+    always_default("")
+  )(active);
+  const renderValueLabel = ifElse_default(
+    always_default(showValues),
+    () => /* @__PURE__ */ jsxRuntime.jsx(
+      FunnelChartValueLabel,
+      {
+        formatPercentage,
+        formatValue,
+        stage
+      }
+    ),
+    always_default(null)
+  );
+  const handleKeyDown = (event) => ifElse_default(
+    (candidate) => candidate.key === "Escape",
+    () => onDeactivate(),
+    always_default(void 0)
+  )(event);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "g",
+    {
+      className: classNames([
+        "pristine-funnel-chart__stage",
+        `pristine-funnel-chart__stage--tone-${String(stage.index % 5 + 1)}`,
+        activeClassName
+      ]),
+      role: "img",
+      "aria-label": getAccessibleLabel(stage, formatValue, formatPercentage),
+      tabIndex: 0,
+      onBlur: onDeactivate,
+      onClick: onActivate,
+      onFocus: onActivate,
+      onKeyDown: handleKeyDown,
+      onMouseEnter: onActivate,
+      onMouseLeave: onDeactivate,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(FunnelChartSegment, { stage }),
+        /* @__PURE__ */ jsxRuntime.jsx(FunnelChartStageLabel, { stage }),
+        renderValueLabel()
+      ]
+    }
+  );
+}
+function FunnelChartStages({
+  activeStage,
+  chart,
+  formatPercentage,
+  formatValue,
+  onActivate,
+  onDeactivate,
+  showValues
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx("g", { className: "pristine-funnel-chart__stages", children: chart.stages.map((stage) => /* @__PURE__ */ jsxRuntime.jsx(
+    FunnelChartStage,
+    {
+      active: stage.stage === activeStage,
+      formatPercentage,
+      formatValue,
+      onActivate: () => onActivate(stage.stage),
+      onDeactivate,
+      showValues,
+      stage
+    },
+    stage.stage
+  )) });
+}
+var TOOLTIP_HEIGHT = 22;
+var TOOLTIP_MIN_WIDTH = 64;
+var TOOLTIP_PADDING_X = 8;
+var TOOLTIP_CHAR_WIDTH = 7;
+var VIEWBOX_PADDING = 4;
+var getTooltipWidth = (label) => Math.max(TOOLTIP_MIN_WIDTH, label.length * TOOLTIP_CHAR_WIDTH + TOOLTIP_PADDING_X * 2);
+var clamp = (minimum, maximum, value) => Math.min(Math.max(value, minimum), maximum);
+var getTooltipLabel = (stage, formatValue, formatPercentage) => matchOption(stage.dropOff, {
+  none: () => `${stage.stage}: ${formatValue(stage.value)}`,
+  some: (dropOff) => `${stage.stage}: ${formatValue(stage.value)} | Drop-off ${formatValue(dropOff)} | ${matchOption(
+    stage.dropOffRate,
+    {
+      none: () => "0%",
+      some: formatPercentage
+    }
+  )} lost`
+});
+function FunnelChartTooltip({
+  stage,
+  formatValue,
+  formatPercentage,
+  height,
+  width
+}) {
+  const label = getTooltipLabel(stage, formatValue, formatPercentage);
+  const tooltipWidth = getTooltipWidth(label);
+  const x = clamp(
+    VIEWBOX_PADDING,
+    width - tooltipWidth - VIEWBOX_PADDING,
+    stage.centerX - tooltipWidth / 2
+  );
+  const y = clamp(
+    VIEWBOX_PADDING,
+    height - TOOLTIP_HEIGHT - VIEWBOX_PADDING,
+    stage.centerY - TOOLTIP_HEIGHT / 2
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("g", { className: "pristine-funnel-chart__tooltip", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "rect",
+      {
+        className: "pristine-funnel-chart__tooltip-background",
+        x,
+        y,
+        width: tooltipWidth,
+        height: TOOLTIP_HEIGHT,
+        rx: 4
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "text",
+      {
+        className: "pristine-funnel-chart__tooltip-text",
+        x: x + tooltipWidth / 2,
+        y: y + TOOLTIP_HEIGHT / 2,
+        textAnchor: "middle",
+        children: label
+      }
+    )
+  ] });
+}
+function FunnelChartSvg({
+  ariaLabel,
+  chart,
+  formatPercentage,
+  formatValue,
+  height,
+  showValues,
+  width
+}) {
+  const [activeStage, setActiveStage] = react.useState(null);
+  const activeStages = chart.stages.filter((stage) => stage.stage === activeStage);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      className: "pristine-funnel-chart__svg",
+      viewBox: `0 0 ${width} ${height}`,
+      role: "img",
+      "aria-label": ariaLabel,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "rect",
+          {
+            className: "pristine-funnel-chart__plot",
+            x: chart.plotLeft,
+            y: chart.plotTop,
+            width: chart.plotRight - chart.plotLeft,
+            height: chart.plotBottom - chart.plotTop
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          FunnelChartStages,
+          {
+            activeStage,
+            chart,
+            formatPercentage,
+            formatValue,
+            onActivate: setActiveStage,
+            onDeactivate: () => setActiveStage(null),
+            showValues
+          }
+        ),
+        activeStages.map((stage) => /* @__PURE__ */ jsxRuntime.jsx(
+          FunnelChartTooltip,
+          {
+            formatPercentage,
+            formatValue,
+            height,
+            stage,
+            width
+          },
+          stage.stage
+        ))
+      ]
+    }
+  );
+}
+function FunnelChartFigure({
+  ariaLabel,
+  caption,
+  chart,
+  className,
+  formatPercentage,
+  formatValue,
+  height,
+  showValues,
+  width
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("figure", { className: classNames(["pristine-funnel-chart", className]), "aria-label": ariaLabel, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      FunnelChartSvg,
+      {
+        ariaLabel,
+        chart,
+        formatPercentage,
+        formatValue,
+        height,
+        showValues,
+        width
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(FunnelChartCaption, { caption })
+  ] });
+}
+function FunnelChart({
+  data,
+  width,
+  height,
+  ariaLabel,
+  className,
+  caption,
+  showValues,
+  formatValue,
+  formatPercentage
+}) {
+  const result = react.useMemo(() => computeFunnelChart({ data }), [data]);
+  return matchResult(result, {
+    error: (error) => /* @__PURE__ */ jsxRuntime.jsx(
+      ChartError,
+      {
+        className: classNames(["pristine-funnel-chart__error", className]),
+        title: "Chart unavailable",
+        message: error.message,
+        details: error.details,
+        role: "alert"
+      }
+    ),
+    ok: (stages) => {
+      const chart = buildFunnelChartModel(stages, width, height);
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        FunnelChartFigure,
+        {
+          ariaLabel,
+          caption,
+          chart,
+          className,
+          formatPercentage,
+          formatValue,
+          height,
+          showValues,
+          width
+        }
+      );
+    }
+  });
+}
+
+// src/funnel-chart/FunnelChart.defaults.ts
+var formatFunnelChartNumber = (value) => String(value);
+var formatFunnelChartPercentage = (rate) => `${(rate * 100).toFixed(0)}%`;
+var DEFAULT_FUNNEL_CHART_VIEW_PROPS = {
+  width: 480,
+  height: 280,
+  ariaLabel: "Funnel chart",
+  className: "",
+  caption: none,
+  showValues: true,
+  formatValue: formatFunnelChartNumber,
+  formatPercentage: formatFunnelChartPercentage
+};
+
+exports.DEFAULT_FUNNEL_CHART_VIEW_PROPS = DEFAULT_FUNNEL_CHART_VIEW_PROPS;
+exports.FunnelChart = FunnelChart;
+exports.computeFunnelChart = computeFunnelChart;
+exports.formatFunnelChartNumber = formatFunnelChartNumber;
+exports.formatFunnelChartPercentage = formatFunnelChartPercentage;
+exports.validateFunnelChartInput = validateFunnelChartInput;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map