pristine-charts 0.1.0

package/dist/bar-chart/index.js

@@ -0,0 +1,1802 @@
+import { useMemo, useState } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { scaleBand, scaleLinear, min, max as max$1 } from 'd3';
+
+// src/bar-chart/BarChart.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/internal/_checkForMethod.js
+function _checkForMethod(methodname, fn) {
+  return function() {
+    var length = arguments.length;
+    if (length === 0) {
+      return fn();
+    }
+    var obj = arguments[length - 1];
+    return isArray_default(obj) || typeof obj[methodname] !== "function" ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/slice.js
+var slice = /* @__PURE__ */ _curry3(/* @__PURE__ */ _checkForMethod("slice", function slice2(fromIndex, toIndex, list) {
+  return Array.prototype.slice.call(list, fromIndex, toIndex);
+}));
+var slice_default = slice;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isTypedArray.js
+function _isTypedArray(val) {
+  var type3 = Object.prototype.toString.call(val);
+  return type3 === "[object Uint8ClampedArray]" || type3 === "[object Int8Array]" || type3 === "[object Uint8Array]" || type3 === "[object Int16Array]" || type3 === "[object Uint16Array]" || type3 === "[object Int32Array]" || type3 === "[object Uint32Array]" || type3 === "[object Float32Array]" || type3 === "[object Float64Array]" || type3 === "[object BigInt64Array]" || type3 === "[object BigUint64Array]";
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/empty.js
+var empty = /* @__PURE__ */ _curry1(function empty2(x) {
+  return x != null && typeof x["fantasy-land/empty"] === "function" ? x["fantasy-land/empty"]() : x != null && x.constructor != null && typeof x.constructor["fantasy-land/empty"] === "function" ? x.constructor["fantasy-land/empty"]() : x != null && typeof x.empty === "function" ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === "function" ? x.constructor.empty() : isArray_default(x) ? [] : _isString(x) ? "" : _isObject(x) ? {} : isArguments_default(x) ? /* @__PURE__ */ (function() {
+    return arguments;
+  })() : _isTypedArray(x) ? x.constructor.from("") : void 0;
+});
+var empty_default = empty;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/isEmpty.js
+var isEmpty = /* @__PURE__ */ _curry1(function isEmpty2(x) {
+  return x != null && equals_default(x, empty_default(x));
+});
+var isEmpty_default = isEmpty;
+
+// 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;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_pipe.js
+function _pipe(f, g) {
+  return function() {
+    return g.call(this, f.apply(this, arguments));
+  };
+}
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/tail.js
+var tail = /* @__PURE__ */ _curry1(/* @__PURE__ */ _checkForMethod("tail", /* @__PURE__ */ slice_default(1, Infinity)));
+var tail_default = tail;
+
+// node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/pipe.js
+function pipe() {
+  if (arguments.length === 0) {
+    throw new Error("pipe requires at least one argument");
+  }
+  return _arity(arguments[0].length, reduce_default(_pipe, arguments[0], tail_default(arguments)));
+}
+
+// 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 isNone = (option) => option.status === "none";
+var fromNullable = (value) => ifElse_default(
+  isNil_default,
+  always_default(none),
+  some
+)(value);
+var getOrElse = (fallback) => (option) => ifElse_default(
+  isSome,
+  (someOption) => someOption.value,
+  always_default(fallback)
+)(option);
+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);
+var bindResult = (transform, merge) => (result) => andThenResult(
+  (context) => mapResult((value) => merge(context, value))(
+    transform(context)
+  )
+)(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__ */ jsx("p", { className: "pristine-chart-error__details", children: value })
+});
+function ChartError({
+  title,
+  message,
+  details,
+  className,
+  role
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: classNames(["pristine-chart-error", className]), role, children: [
+    /* @__PURE__ */ jsx("p", { className: "pristine-chart-error__title", children: title }),
+    /* @__PURE__ */ jsx("p", { className: "pristine-chart-error__message", children: message }),
+    renderDetails(details)
+  ] });
+}
+
+// src/bar-chart/BarChart.domain.ts
+var DEFAULT_BAR_CHART_ORDER_STRATEGY = {
+  kind: "insertion"
+};
+var VALUE_ORDER_FALLBACK = "ascending";
+var barChartRules = {
+  emptyDataset: () => ({
+    type: "EmptyDataset",
+    message: "A bar chart needs at least one category.",
+    details: none
+  }),
+  invalidValue: (index) => ({
+    type: "InvalidValue",
+    message: "Every bar chart value must be a finite number.",
+    details: some(`Invalid value at index ${String(index)}.`)
+  }),
+  duplicateCategory: (category) => ({
+    type: "DuplicateCategory",
+    message: "Bar chart categories must be unique.",
+    details: some(`Duplicate category: ${category}.`)
+  }),
+  emptyCategoryName: (index) => ({
+    type: "EmptyCategoryName",
+    message: "Every bar chart category needs a non-empty name.",
+    details: some(`Empty category at index ${String(index)}.`)
+  }),
+  missingValueSortDirection: () => ({
+    type: "MissingValueSortDirection",
+    message: "Sorting by value requires an ascending or descending direction.",
+    details: none
+  }),
+  missingCategoriesInCustomOrder: (categories) => ({
+    type: "MissingCategoriesInCustomOrder",
+    message: "Custom bar chart ordering must include every category.",
+    details: some(`Missing categories: ${categories.join(", ")}.`)
+  })
+};
+var isFiniteNumber = (value) => allPass_default([
+  (candidate) => typeof candidate === "number",
+  (candidate) => Number.isFinite(candidate)
+])(value);
+var isNonEmptyString = (value) => value.trim().length > 0;
+var getCategories = (data) => map_default(prop_default("category"), [...data]);
+var getValues = (data) => map_default(prop_default("value"), [...data]);
+var hasOnlyFiniteValues = (data) => all_default(isFiniteNumber, getValues(data));
+var findInvalidValueIndex = (data) => findIndex_default(complement_default(isFiniteNumber), getValues(data));
+var findEmptyCategoryIndex = (data) => findIndex_default(complement_default(isNonEmptyString), getCategories(data));
+var hasOnlyNamedCategories = (data) => all_default(isNonEmptyString, getCategories(data));
+var hasUniqueCategories = (data) => {
+  const categories = getCategories(data);
+  return categories.length === new Set(categories).size;
+};
+var findDuplicateCategory = (data) => {
+  const categories = getCategories(data);
+  return defaultTo_default(
+    "unknown category",
+    categories.find((category, index) => categories.indexOf(category) !== index)
+  );
+};
+var isByValueOrderStrategy = (strategy) => strategy.kind === "value";
+var isCustomOrderStrategy = (strategy) => strategy.kind === "custom";
+var getValueOrderDirection = (strategy) => ifElse_default(
+  isByValueOrderStrategy,
+  (valueStrategy) => fromNullable(valueStrategy.direction),
+  always_default(some(VALUE_ORDER_FALLBACK))
+)(strategy);
+var isMissingValueSortDirection = (strategy) => allPass_default([
+  isByValueOrderStrategy,
+  pipe(getValueOrderDirection, isNone)
+])(strategy);
+var getCustomOrderCategories = (strategy) => ifElse_default(
+  isCustomOrderStrategy,
+  (customStrategy) => customStrategy.categories,
+  always_default([])
+)(strategy);
+var includesCategory = (categories) => (category) => categories.includes(category);
+var getMissingCustomCategories = (data, strategy) => filter_default(
+  complement_default(includesCategory(getCustomOrderCategories(strategy))),
+  getCategories(data)
+);
+var isMissingCustomCategories = (input) => allPass_default([
+  (candidate) => isCustomOrderStrategy(candidate.orderStrategy),
+  (candidate) => complement_default(isEmpty_default)(getMissingCustomCategories(candidate.data, candidate.orderStrategy))
+])(input);
+var datasetValidators = [
+  [isEmpty_default, () => err(barChartRules.emptyDataset())],
+  [
+    complement_default(hasOnlyFiniteValues),
+    (candidate) => err(barChartRules.invalidValue(findInvalidValueIndex(candidate)))
+  ],
+  [
+    complement_default(hasOnlyNamedCategories),
+    (candidate) => err(barChartRules.emptyCategoryName(findEmptyCategoryIndex(candidate)))
+  ],
+  [
+    complement_default(hasUniqueCategories),
+    (candidate) => err(barChartRules.duplicateCategory(findDuplicateCategory(candidate)))
+  ],
+  [always_default(true), (candidate) => ok(candidate)]
+];
+var validateDataset = cond_default(datasetValidators);
+var orderStrategyValidators = [
+  [
+    (candidate) => isMissingValueSortDirection(candidate.orderStrategy),
+    () => err(barChartRules.missingValueSortDirection())
+  ],
+  [
+    isMissingCustomCategories,
+    (candidate) => err(
+      barChartRules.missingCategoriesInCustomOrder(
+        getMissingCustomCategories(candidate.data, candidate.orderStrategy)
+      )
+    )
+  ],
+  [always_default(true), (candidate) => ok(candidate.orderStrategy)]
+];
+var validateOrderStrategy = cond_default(orderStrategyValidators);
+function validateBarChartInput(input) {
+  return bindResult(
+    () => validateOrderStrategy(input),
+    (context, orderStrategy) => ({ ...context, orderStrategy })
+  )(
+    bindResult(
+      () => validateDataset(input.data),
+      (_, data) => ({ data })
+    )(ok({}))
+  );
+}
+var byCategory = (left, right) => left.category.localeCompare(right.category);
+var byAscendingValue = (left, right) => left.value - right.value;
+var byDescendingValue = (left, right) => right.value - left.value;
+var byCustomOrder = (categories) => (left, right) => categories.indexOf(left.category) - categories.indexOf(right.category);
+var isAlphabeticalOrderStrategy = (strategy) => strategy.kind === "alphabetical";
+var isInsertionOrderStrategy = (strategy) => strategy.kind === "insertion";
+var isAscendingSortDirection = (direction) => direction === "ascending";
+var getOrderedData = (data, orderStrategy) => cond_default([
+  [isInsertionOrderStrategy, always_default([...data])],
+  [isAlphabeticalOrderStrategy, always_default([...data].sort(byCategory))],
+  [
+    isByValueOrderStrategy,
+    (strategy) => ifElse_default(
+      isAscendingSortDirection,
+      always_default([...data].sort(byAscendingValue)),
+      always_default([...data].sort(byDescendingValue))
+    )(getOrElse(VALUE_ORDER_FALLBACK)(getValueOrderDirection(strategy)))
+  ],
+  [
+    isCustomOrderStrategy,
+    (strategy) => [...data].sort(byCustomOrder(strategy.categories))
+  ]
+])(orderStrategy);
+var POSITIVE_DIRECTION = "positive";
+var NEGATIVE_DIRECTION = "negative";
+var ZERO_DIRECTION = "zero";
+var barDirectionRules = [
+  [(candidate) => candidate > 0, always_default(POSITIVE_DIRECTION)],
+  [(candidate) => candidate < 0, always_default(NEGATIVE_DIRECTION)],
+  [always_default(true), always_default(ZERO_DIRECTION)]
+];
+var getBarDirection = cond_default(barDirectionRules);
+var toBar = (datum) => ({
+  ...datum,
+  direction: getBarDirection(datum.value)
+});
+var computeBars = (input) => map_default(toBar, getOrderedData(input.data, input.orderStrategy));
+function computeBarChart(input) {
+  return mapResult(computeBars)(
+    validateBarChartInput(input)
+  );
+}
+var BAR_CHART_MARGIN = {
+  top: 24,
+  right: 16,
+  bottom: 42,
+  left: 42
+};
+var getMinValue = (bars) => withNumberDefault(0)(min(map_default(prop_default("value"), [...bars])));
+var getMaxValue = (bars) => withNumberDefault(0)(max$1(map_default(prop_default("value"), [...bars])));
+var getLowerDomain = (bars) => Math.min(0, getMinValue(bars));
+var getUpperDomain = (bars) => Math.max(0, getMaxValue(bars));
+var getCategory = (bar) => bar.category;
+var getValueY = (plotBottom) => (bar, y, height) => ifElse_default(
+  (candidate) => candidate.direction === "negative",
+  always_default(Math.min(plotBottom - 6, y + height + 12)),
+  always_default(Math.max(BAR_CHART_MARGIN.top + 10, y - 6))
+)(bar);
+var buildBarChartModel = (bars, width, height) => {
+  const plotBottom = height - BAR_CHART_MARGIN.bottom;
+  const xScale = scaleBand().domain(map_default(getCategory, [...bars])).range([BAR_CHART_MARGIN.left, width - BAR_CHART_MARGIN.right]).padding(0.22);
+  const yScale = scaleLinear().domain([getLowerDomain(bars), getUpperDomain(bars)]).nice().range([plotBottom, BAR_CHART_MARGIN.top]);
+  const baselineY = yScale(0);
+  const toRenderedBar = (bar) => {
+    const y = Math.min(yScale(bar.value), baselineY);
+    const barHeight = Math.abs(baselineY - yScale(bar.value));
+    return {
+      ...bar,
+      x: withNumberDefault(BAR_CHART_MARGIN.left)(xScale(bar.category)),
+      y,
+      width: xScale.bandwidth(),
+      height: barHeight,
+      valueY: getValueY(plotBottom)(bar, y, barHeight)
+    };
+  };
+  return {
+    baselineY,
+    plotBottom,
+    yTicks: yScale.ticks(5),
+    bars: map_default(toRenderedBar, [...bars]),
+    yScale
+  };
+};
+function BarChartCaption({ caption }) {
+  return matchOption(caption, {
+    none: () => null,
+    some: (value) => /* @__PURE__ */ jsx("figcaption", { className: "pristine-bar-chart__caption", children: value })
+  });
+}
+function BarChartAxes({ chart, width }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "line",
+      {
+        className: "pristine-bar-chart__axis",
+        x1: BAR_CHART_MARGIN.left,
+        x2: width - BAR_CHART_MARGIN.right,
+        y1: chart.baselineY,
+        y2: chart.baselineY
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "line",
+      {
+        className: "pristine-bar-chart__axis",
+        x1: BAR_CHART_MARGIN.left,
+        x2: BAR_CHART_MARGIN.left,
+        y1: BAR_CHART_MARGIN.top,
+        y2: chart.plotBottom
+      }
+    )
+  ] });
+}
+var getHitAreaY = ifElse_default(
+  (bar) => bar.height > 0,
+  (bar) => bar.y,
+  (bar) => bar.y - 4
+);
+function BarChartBar({ bar }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "rect",
+      {
+        className: `pristine-bar-chart__bar pristine-bar-chart__bar--${bar.direction}`,
+        x: bar.x,
+        y: bar.y,
+        width: bar.width,
+        height: bar.height,
+        "aria-hidden": "true"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "rect",
+      {
+        className: "pristine-bar-chart__bar-hit-area",
+        x: bar.x,
+        y: getHitAreaY(bar),
+        width: bar.width,
+        height: Math.max(bar.height, 8),
+        "aria-hidden": "true"
+      }
+    )
+  ] });
+}
+function BarChartCategoryLabel({ bar, height }) {
+  return /* @__PURE__ */ jsx(
+    "text",
+    {
+      className: "pristine-bar-chart__label",
+      x: bar.x + bar.width / 2,
+      y: height - 12,
+      textAnchor: "middle",
+      children: bar.category
+    }
+  );
+}
+function BarChartValueLabel({ bar, formatValue }) {
+  return /* @__PURE__ */ jsx(
+    "text",
+    {
+      className: "pristine-bar-chart__value",
+      x: bar.x + bar.width / 2,
+      y: bar.valueY,
+      textAnchor: "middle",
+      children: formatValue(bar.value)
+    }
+  );
+}
+function BarChartCategory({
+  active,
+  bar,
+  formatValue,
+  height,
+  onActivate,
+  onDeactivate,
+  showValues
+}) {
+  const renderValueLabel = ifElse_default(
+    always_default(showValues),
+    () => /* @__PURE__ */ jsx(BarChartValueLabel, { bar, formatValue }),
+    always_default(null)
+  );
+  const activeClassName = ifElse_default(
+    always_default(active),
+    always_default("pristine-bar-chart__category--active"),
+    always_default("")
+  )(active);
+  const accessibleLabel = `${bar.category}: ${formatValue(bar.value)}`;
+  const handleKeyDown = (event) => ifElse_default(
+    (candidate) => candidate.key === "Escape",
+    () => onDeactivate(),
+    always_default(void 0)
+  )(event);
+  return /* @__PURE__ */ jsxs(
+    "g",
+    {
+      className: classNames([
+        "pristine-bar-chart__category",
+        activeClassName
+      ]),
+      role: "img",
+      "aria-label": accessibleLabel,
+      tabIndex: 0,
+      onBlur: onDeactivate,
+      onClick: onActivate,
+      onFocus: onActivate,
+      onKeyDown: handleKeyDown,
+      onMouseEnter: onActivate,
+      onMouseLeave: onDeactivate,
+      children: [
+        /* @__PURE__ */ jsx(BarChartBar, { bar }),
+        renderValueLabel(),
+        /* @__PURE__ */ jsx(BarChartCategoryLabel, { bar, height })
+      ]
+    }
+  );
+}
+function BarChartCategories({
+  activeCategory,
+  chart,
+  formatValue,
+  height,
+  onActivate,
+  onDeactivate,
+  showValues
+}) {
+  return chart.bars.map((bar) => /* @__PURE__ */ jsx(
+    BarChartCategory,
+    {
+      active: activeCategory === bar.category,
+      bar,
+      formatValue,
+      height,
+      onActivate: () => onActivate(bar.category),
+      onDeactivate,
+      showValues
+    },
+    bar.category
+  ));
+}
+function BarChartGridLines({ chart, width }) {
+  return chart.yTicks.map((tick) => /* @__PURE__ */ jsxs("g", { className: "pristine-bar-chart__grid-line", children: [
+    /* @__PURE__ */ jsx(
+      "line",
+      {
+        x1: BAR_CHART_MARGIN.left,
+        x2: width - BAR_CHART_MARGIN.right,
+        y1: chart.yScale(tick),
+        y2: chart.yScale(tick)
+      }
+    ),
+    /* @__PURE__ */ jsx("text", { x: BAR_CHART_MARGIN.left - 8, y: chart.yScale(tick), textAnchor: "end", children: tick })
+  ] }, tick));
+}
+function BarChartPlotArea({ chart, width }) {
+  return /* @__PURE__ */ jsx(
+    "rect",
+    {
+      className: "pristine-bar-chart__plot",
+      x: BAR_CHART_MARGIN.left,
+      y: BAR_CHART_MARGIN.top,
+      width: width - BAR_CHART_MARGIN.left - BAR_CHART_MARGIN.right,
+      height: chart.plotBottom - BAR_CHART_MARGIN.top
+    }
+  );
+}
+var TOOLTIP_HEIGHT = 22;
+var TOOLTIP_MIN_WIDTH = 30;
+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);
+function BarChartTooltip({
+  bar,
+  formatValue,
+  height,
+  width
+}) {
+  const label = formatValue(bar.value);
+  const tooltipWidth = getTooltipWidth(label);
+  const x = clamp(
+    VIEWBOX_PADDING,
+    width - tooltipWidth - VIEWBOX_PADDING,
+    bar.x + bar.width / 2 - tooltipWidth / 2
+  );
+  const y = clamp(
+    VIEWBOX_PADDING,
+    height - TOOLTIP_HEIGHT - VIEWBOX_PADDING,
+    bar.valueY - TOOLTIP_HEIGHT / 2
+  );
+  return /* @__PURE__ */ jsxs("g", { className: "pristine-bar-chart__tooltip", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx(
+      "rect",
+      {
+        className: "pristine-bar-chart__tooltip-background",
+        x,
+        y,
+        width: tooltipWidth,
+        height: TOOLTIP_HEIGHT,
+        rx: 4
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "text",
+      {
+        className: "pristine-bar-chart__tooltip-text",
+        x: x + tooltipWidth / 2,
+        y: y + TOOLTIP_HEIGHT / 2,
+        textAnchor: "middle",
+        children: label
+      }
+    )
+  ] });
+}
+function BarChartSvg({
+  ariaLabel,
+  chart,
+  formatValue,
+  height,
+  showValues,
+  width
+}) {
+  const [activeCategory, setActiveCategory] = useState(null);
+  const activeBars = chart.bars.filter((bar) => bar.category === activeCategory);
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      className: "pristine-bar-chart__svg",
+      viewBox: `0 0 ${width} ${height}`,
+      role: "img",
+      "aria-label": ariaLabel,
+      children: [
+        /* @__PURE__ */ jsx(BarChartPlotArea, { chart, width }),
+        /* @__PURE__ */ jsx(BarChartGridLines, { chart, width }),
+        /* @__PURE__ */ jsx(BarChartAxes, { chart, width }),
+        /* @__PURE__ */ jsx(
+          BarChartCategories,
+          {
+            activeCategory,
+            chart,
+            formatValue,
+            height,
+            onActivate: setActiveCategory,
+            onDeactivate: () => setActiveCategory(null),
+            showValues
+          }
+        ),
+        activeBars.map((bar) => /* @__PURE__ */ jsx(
+          BarChartTooltip,
+          {
+            bar,
+            formatValue,
+            height,
+            width
+          },
+          bar.category
+        ))
+      ]
+    }
+  );
+}
+function BarChartFigure({
+  ariaLabel,
+  caption,
+  chart,
+  className,
+  formatValue,
+  height,
+  showValues,
+  width
+}) {
+  return /* @__PURE__ */ jsxs("figure", { className: classNames(["pristine-bar-chart", className]), "aria-label": ariaLabel, children: [
+    /* @__PURE__ */ jsx(
+      BarChartSvg,
+      {
+        ariaLabel,
+        chart,
+        formatValue,
+        height,
+        showValues,
+        width
+      }
+    ),
+    /* @__PURE__ */ jsx(BarChartCaption, { caption })
+  ] });
+}
+function BarChart({
+  data,
+  width,
+  height,
+  ariaLabel,
+  className,
+  caption,
+  orderStrategy,
+  showValues,
+  formatValue
+}) {
+  const result = useMemo(
+    () => computeBarChart({ data, orderStrategy }),
+    [data, orderStrategy]
+  );
+  return matchResult(result, {
+    error: (error) => /* @__PURE__ */ jsx(
+      ChartError,
+      {
+        className: classNames(["pristine-bar-chart__error", className]),
+        title: "Chart unavailable",
+        message: error.message,
+        details: error.details,
+        role: "alert"
+      }
+    ),
+    ok: (bars) => {
+      const chart = buildBarChartModel(bars, width, height);
+      return /* @__PURE__ */ jsx(
+        BarChartFigure,
+        {
+          ariaLabel,
+          caption,
+          chart,
+          className,
+          formatValue,
+          height,
+          showValues,
+          width
+        }
+      );
+    }
+  });
+}
+
+// src/bar-chart/BarChart.defaults.ts
+var formatDefaultValue = (value) => String(value);
+var DEFAULT_BAR_CHART_VIEW_PROPS = {
+  width: 480,
+  height: 280,
+  ariaLabel: "Bar chart",
+  className: "",
+  caption: none,
+  orderStrategy: DEFAULT_BAR_CHART_ORDER_STRATEGY,
+  showValues: false,
+  formatValue: formatDefaultValue
+};
+
+export { BarChart, DEFAULT_BAR_CHART_ORDER_STRATEGY, DEFAULT_BAR_CHART_VIEW_PROPS, computeBarChart, validateBarChartInput };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map