@hestia-earth/ui-components-charts 0.43.23 → 0.43.24

package/dist/index.js

@@ -3,12 +3,28 @@
 var utils = require('@hestia-earth/utils');
 var Gradient = require('javascript-color-gradient');
 var shadeGenerator = require('shade-generator/dist/shadeGenerator');
+var d3Selection = require('d3-selection');
+var merge = require('lodash.merge');
 var emissionGroupings = require('@hestia-earth/glossary/resources/emission-groupings.json');
+var chart_js = require('chart.js');
+var C2S = require('canvas-to-svg');
+var schema = require('@hestia-earth/schema');
+var defaultModelIds = require('@hestia-earth/glossary/resources/defaultModelId.json');
+var d3Shape = require('d3-shape');
+require('d3-transition');
+var d3Hierarchy = require('d3-hierarchy');
+var d3Ease = require('d3-ease');
+require('chartjs-adapter-date-fns');
+var annotationPlugin = require('chartjs-plugin-annotation');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var Gradient__default = /*#__PURE__*/_interopDefault(Gradient);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
 var emissionGroupings__default = /*#__PURE__*/_interopDefault(emissionGroupings);
+var C2S__default = /*#__PURE__*/_interopDefault(C2S);
+var defaultModelIds__default = /*#__PURE__*/_interopDefault(defaultModelIds);
+var annotationPlugin__default = /*#__PURE__*/_interopDefault(annotationPlugin);
 
 // src/charts/bar.ts
 
@@ -18,6 +34,17 @@ var defaultTicksFont = {
   size: 13
 };
 var chartLabelMaxLength = 50;
+var defaultChartSettings = Object.freeze({
+  options: {
+    responsive: true,
+    maintainAspectRatio: false,
+    plugins: {
+      legend: {
+        display: false
+      }
+    }
+  }
+});
 
 // src/charts/bar.ts
 var grey = "#4a4a4a";
@@ -151,20 +178,20 @@ var palette = Object.freeze({
   ]
 });
 var getGradients = (...colours) => new Gradient__default.default().setColorGradient(...colours).setMidpoint(10).getColors();
-var getColorGradient = (index, colors) => {
-  const start = colors[index % colors.length];
-  const end = colors[index % colors.length + 1];
-  const gradientIndex = Math.ceil(index / colors.length);
+var getColorGradient = (index, colors2) => {
+  const start = colors2[index % colors2.length];
+  const end = colors2[index % colors2.length + 1];
+  const gradientIndex = Math.ceil(index / colors2.length);
   return getGradients(start, end)[gradientIndex];
 };
-var getColorShade = (index, colors) => {
-  const color = colors[index % colors.length];
-  const shade = Math.min(100, Math.max(10, Math.abs(100 - Math.ceil(index / colors.length) * 10)));
+var getColorShade = (index, colors2) => {
+  const color = colors2[index % colors2.length];
+  const shade = Math.min(100, Math.max(10, Math.abs(100 - Math.ceil(index / colors2.length) * 10)));
   return shadeGenerator.ShadeGenerator.hue(color).shade(`${shade}`).hex();
 };
 var getColor = (index, scheme = 0 /* categorial */) => {
-  const colors = palette[scheme];
-  return index < colors.length ? colors[index] : scheme === 0 /* categorial */ ? getColorShade(index, colors) : getColorGradient(index, colors);
+  const colors2 = palette[scheme];
+  return index < colors2.length ? colors2[index] : scheme === 0 /* categorial */ ? getColorShade(index, colors2) : getColorGradient(index, colors2);
 };
 var listColor = (_v, index) => getColor(index);
 var listColorContinuous = (_v, index) => getColor(index, 1 /* continuous */);
@@ -225,48 +252,12 @@ var groupDataByCategory = (data2, labels, category, { emissionCategoryValue: emi
 // src/charts/csv.ts
 var escape = (value) => `${value}`.includes(",") ? `"${value}"` : value;
 var toLine = (values) => values.map(escape).join(",");
-var data = emissionGroupings__default.default;
-var categoryLabel = (key) => key ? utils.keyToLabel(key.replace(/category/gi, "")) : "Unset";
-var emissionCategories = Object.keys(data).filter((key) => key.toLowerCase().endsWith("category")).map((key) => ({ key, label: categoryLabel(key) }));
-var categoryValues = (category) => data[category];
-var emissionCategoriesOf = (emissionId) => Object.keys(data[emissionId]).filter((key) => !!data[emissionId][key]);
-var emissionCategoryValue = (emissionId, category) => {
-  var _a;
-  return (_a = data[emissionId]) == null ? void 0 : _a[category];
-};
-var defaultHorizontalBarConfig = Object.freeze({
-  options: {
-    indexAxis: "y",
-    scales: {
-      x: {
-        grid: {
-          drawOnChartArea: false
-        },
-        ticks: {
-          callback: (value) => utils.toPrecision(Number(value), 3)
-        }
-      },
-      y: {
-        grid: {
-          drawOnChartArea: false
-        },
-        ticks: {
-          crossAlign: "near"
-        }
-      }
-    }
-  }
-});
-var defaultHorizontalTooltip = ({ label, count, includedItems }) => (includedItems == null ? void 0 : includedItems.length) ? includedItems.map(defaultHorizontalTooltip).join("</br>") : `${label}: ${count}`;
-var rowHeight = 40;
-var padding = 60;
-var horizontalBarHeight = (minHeight, maxHeight, nbRows) => Math.min(Math.max(nbRows * rowHeight + padding, minHeight), maxHeight);
 var placementGap = (placement) => placement === "right" ? 8 : -8;
 var placementX = (x, chart, data2, placement) => placement === "right" ? !Array.isArray(data2) && data2 < 0 ? positionAtZero(chart) : x : x;
 var positionAtZero = (chart) => chart.scales.x.getPixelForValue(0);
 var defaultBarDrawSettings = {
   placement: "right",
-  xPosFn: (x, index, width, chart, data2, placement) => (utils.isEmpty(data2) ? positionAtZero(chart) : placementX(x, chart, data2, placement)) + placementGap(placement),
+  xPosFn: (x, index, width2, chart, data2, placement) => (utils.isEmpty(data2) ? positionAtZero(chart) : placementX(x, chart, data2, placement)) + placementGap(placement),
   yPosFn: (y) => y + 3,
   colorFn: (m, index, chart, data2) => utils.isUndefined(data2) ? "#b5b5b5" : "#4a4a4a",
   textFn: ({ data: data2 }) => `${data2}`,
@@ -305,7 +296,7 @@ var afterBarDrawPlugin = (settings) => ({
       ...defaultBarDrawSettings,
       ...settings != null ? settings : {}
     };
-    const { ctx, width, height } = chart;
+    const { ctx, width: width2, height } = chart;
     ctx.save();
     const getStackItems = (index) => chart.data.datasets.map((dataset, dsIndex) => ({ dataset, meta: chart.getDatasetMeta(dsIndex) })).filter(({ meta }) => !meta.hidden).map(({ dataset, meta }) => ({
       element: meta.data[index],
@@ -331,7 +322,7 @@ var afterBarDrawPlugin = (settings) => ({
       var _a2, _b2;
       return (_b2 = (_a2 = chart.data.labels) == null ? void 0 : _a2[index]) != null ? _b2 : "";
     };
-    const getXPos = (anchorX, index, dataToPass) => xPosFn(anchorX, index, width, chart, dataToPass, placement);
+    const getXPos = (anchorX, index, dataToPass) => xPosFn(anchorX, index, width2, chart, dataToPass, placement);
     const getYPos = (y, index, dataToPass) => yPosFn(y, index, height, chart, dataToPass, placement);
     const getAnchorX = (minX, maxX) => placement === "left" ? minX : maxX;
     const processIndex = (index) => {
@@ -414,16 +405,16 @@ var createHoverGradient = (ctx, chartArea, color) => {
   return gradient;
 };
 var calculateBarBounds = (element, indexAxis = "y") => {
-  const { x, y, base, width, height } = element;
+  const { x, y, base, width: width2, height } = element;
   if (indexAxis === "y") {
-    const barHeight = height;
-    const barTop = y - barHeight / 2;
-    const barBottom = y + barHeight / 2;
+    const barHeight2 = height;
+    const barTop = y - barHeight2 / 2;
+    const barBottom = y + barHeight2 / 2;
     const barLeft = Math.min(base, x);
     const barRight = Math.max(base, x);
-    return { barLeft, barRight, barTop, barBottom, thickness: barHeight };
+    return { barLeft, barRight, barTop, barBottom, thickness: barHeight2 };
   } else {
-    const barWidth = width;
+    const barWidth = width2;
     const barLeft = x - barWidth / 2;
     const barRight = x + barWidth / 2;
     const barTop = Math.min(base, y);
@@ -670,13 +661,1389 @@ var lollipopChartPlugin = (settings) => ({
 var increaseScaleLimits = (scale, handleMinScaleZero = true) => {
   const range = scale.max - scale.min;
   const safeRange = range === 0 ? Math.abs(scale.max) || 1 : range;
-  const margin = 0.1;
-  const padding2 = safeRange * margin;
+  const margin2 = 0.1;
+  const padding2 = safeRange * margin2;
   scale.min -= handleMinScaleZero && scale.min === 0 ? 0 : padding2;
   scale.max += padding2;
 };
+var parsePrecision = (value, precision = 3) => utils.toPrecision(parseFloat(`${value}`), parseInt(`${precision}`, 10));
+var formatPrecision = (value, precision = 3, enableComma = true) => typeof value !== "boolean" && !utils.isUndefined(value) && utils.isNumber(value) ? `${(enableComma ? utils.toComma : (v) => v)(parsePrecision(value, precision))}`.replace(/\.00$/, "") : value;
+
+// src/charts/contribution-chart.ts
+var grey2 = "#4a4a4a";
+var contributionBarHeight = 8;
+var contributionHoverHeight = 10;
+var defaultContributionSettings = Object.freeze({
+  type: "bar",
+  options: {
+    indexAxis: "y",
+    responsive: true,
+    plugins: {
+      tooltip: {
+        enabled: false
+      },
+      legend: {
+        display: false
+      }
+    },
+    scales: {
+      x: {
+        stacked: true,
+        display: true,
+        grid: {
+          display: true,
+          drawOnChartArea: true
+        },
+        ticks: {
+          font: defaultTicksFont,
+          callback: (label) => `${formatPrecision(+label)}`
+        }
+      },
+      y: {
+        stacked: true,
+        display: true,
+        position: "left",
+        grid: {
+          display: true,
+          drawOnChartArea: false,
+          drawTicks: true,
+          tickLength: 8,
+          offset: false
+        },
+        ticks: {
+          color: grey2,
+          padding: 4,
+          crossAlign: "center",
+          font: {
+            ...defaultTicksFont,
+            weight: 400
+          },
+          callback: function(value) {
+            const label = this.getLabelForValue(value);
+            return utils.ellipsis(label, chartLabelMaxLength);
+          }
+        }
+      }
+    }
+  }
+});
+var contributionChartHeight = (minHeight, maxHeight, nbRows) => {
+  const rowHeight2 = contributionBarHeight + contributionHoverHeight * 2;
+  const padding2 = 60;
+  return Math.min(Math.max(nbRows * rowHeight2 + padding2, minHeight), maxHeight);
+};
+var datasetCenter = (chart, index) => {
+  const elements = chart.data.datasets.map((_, i) => {
+    const meta = chart.getDatasetMeta(i);
+    return meta.hidden ? null : meta.data[index];
+  }).filter((e) => !!e);
+  const right = Math.max(...elements.map((e) => e.x), ...elements.map((e) => e.base));
+  const left = Math.min(...elements.map((e) => e.x), ...elements.map((e) => e.base));
+  return (right + left) / 2;
+};
+var contributionItemColor = (item) => item.backgroundColor || item.borderColor || item.color;
+var dataAtIndex = (data2, index, includeItems = true) => data2.map((item) => {
+  var _a;
+  return {
+    ...item,
+    value: item.values[index],
+    includedItems: includeItems ? (_a = item.includedItems) == null ? void 0 : _a.map((included) => ({
+      ...included,
+      value: included.values[index]
+    })) : []
+  };
+}).filter((v) => !utils.isUndefined(v.value)).sort((a, b) => Math.abs(b.value) - Math.abs(a.value));
+var contributionCsv = (labels, data2) => [
+  toLine(["@id", ...data2.map((v) => v.label)]),
+  labels.map((label, index) => toLine([label, ...dataAtIndex(data2, index, false).map((v) => v.value)])).join("\n")
+].join("\n");
+var hasNegativeValues = (data2 = []) => data2.some((value) => value.values.some((v) => v < 0));
+var contributionData = (data2, labels) => ({
+  datasets: data2.map(
+    (item) => ({
+      label: item.label,
+      data: item.values,
+      backgroundColor: item.backgroundColor || item.color,
+      borderColor: item.borderColor || item.color,
+      barThickness: contributionBarHeight,
+      maxBarThickness: contributionBarHeight,
+      includedItems: item.includedItems
+    })
+  ),
+  labels
+});
+var contributionChartConfig = ({
+  onClick,
+  axis,
+  label,
+  hasNegativeValues: negative,
+  mobile
+}) => ({
+  options: {
+    onClick,
+    plugins: { axisHover: axis },
+    scales: {
+      x: {
+        display: !mobile,
+        afterDataLimits: (scale) => increaseScaleLimits(scale),
+        title: {
+          display: !!label,
+          text: label
+        },
+        grid: {
+          lineWidth: (context) => context.tick.value === 0 && negative ? 1 : 0
+        }
+      },
+      y: {
+        display: !mobile
+      }
+    }
+  },
+  plugins: [
+    backgroundHoverPlugin({ threshold: contributionHoverHeight }),
+    afterBarDrawPlugin({
+      placement: "right",
+      textFn: ({ data: data2 }) => utils.isUndefined(data2) ? "No data" : ""
+    }),
+    ...axis ? [axisHoverPlugin] : []
+  ]
+});
+var d3ellipse = (selection, maxWidth, ellipsisStr = "...") => {
+  selection.each(function() {
+    const t = d3Selection.select(this);
+    if (t.node().getComputedTextLength() > maxWidth) {
+      const chars = t.text().split("");
+      const line2 = [];
+      do {
+        line2.push(chars.shift());
+        t.text(line2.join("") + ellipsisStr);
+      } while (t.node().getComputedTextLength() <= maxWidth);
+    }
+  });
+};
+var shouldBreakLine = (overflows, isMultiWordLine, isOwnLineWord, isUnderLineLimit) => (overflows && isMultiWordLine || isOwnLineWord) && isUnderLineLimit;
+var d3wrap = (t, {
+  maxWidth,
+  maxLines,
+  words,
+  nHeight,
+  lHeight,
+  vcentre = false,
+  ownLineWord = ""
+}) => {
+  words = words.reverse();
+  const y = t.attr("y");
+  const x = t.attr("x");
+  let lineNumber = 1;
+  let word;
+  let line2 = [];
+  let tspan = t.text(null).append("tspan").attr("x", x).attr("y", y);
+  while ((word = words.pop()) && lineNumber <= maxLines) {
+    line2.push(word);
+    tspan.text(line2.join(" "));
+    if (shouldBreakLine(
+      tspan.node().getComputedTextLength() > maxWidth,
+      line2.length > 1,
+      word === ownLineWord,
+      lineNumber < maxLines
+    )) {
+      line2.pop();
+      tspan.text(line2.join(" "));
+      line2 = [word];
+      tspan = t.append("tspan").attr("x", x).attr("y", y).attr("dy", lineNumber++ * lHeight + "px").text(word);
+    }
+  }
+  d3ellipse(tspan, maxWidth, "... " + ownLineWord);
+  if (vcentre) {
+    const yOffset = nHeight / 2 - (t.selectAll("tspan").size() - 1) * (lHeight / 2);
+    t.selectAll("tspan").attr("y", yOffset);
+  }
+};
+var colors = {
+  darkBlue: "rgba(25, 57, 87, 1)",
+  lightBlue: "rgba(132, 160, 220, 1)",
+  // `$warning` — marks the reported value, and is the one colour that reads against both a white
+  // page and the dark blue popover the parametric chart is shown in
+  orange: "rgba(255, 136, 27, 1)"
+};
+var opaqueColor = (color, opacity = 0.5) => color.replace(", 1)", `, ${opacity})`);
+var defaultDistributionSettings = Object.freeze({
+  type: "line",
+  options: {
+    events: [],
+    responsive: true,
+    plugins: {
+      tooltip: {
+        enabled: false
+      },
+      legend: {
+        display: false,
+        align: "center"
+      }
+    },
+    scales: {
+      y: {
+        display: true,
+        position: "left",
+        grid: {
+          display: true
+        },
+        beginAtZero: true,
+        ticks: {
+          crossAlign: "center"
+        }
+      }
+    }
+  }
+});
+var joinXLabel = " to ";
+var createDynamicHistogramData = (values, numberOfBins) => {
+  if (values.length === 0) {
+    return { labels: [], frequencies: [] };
+  }
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const binSize = (max - min) / numberOfBins;
+  const frequencies = new Array(numberOfBins).fill(0);
+  const labels = [];
+  for (let i = 0; i < numberOfBins; i++) {
+    const binStart = min + i * binSize;
+    const binEnd = binStart + binSize;
+    labels.push([binStart, binEnd].join(joinXLabel));
+    values.forEach((point) => {
+      if (point >= binStart && point < binEnd) {
+        frequencies[i]++;
+      }
+    });
+  }
+  frequencies[numberOfBins - 1] += values.filter((p) => p === max).length;
+  return { labels, frequencies };
+};
+var curveSpread = 4;
+var curvePoints = 120;
+var curvePadding = 0.05;
+var normalPdf = (x, mu, sd) => Math.exp(-0.5 * ((x - mu) / sd) ** 2) / (sd * Math.sqrt(2 * Math.PI));
+var curveRange = (mu, sd, value, minX) => {
+  const values = [mu - curveSpread * sd, mu + curveSpread * sd, ...Number.isFinite(value) ? [value] : []];
+  const from = Math.min(...values);
+  const to = Math.max(...values);
+  const padding2 = (to - from) * curvePadding;
+  return { from: Number.isFinite(minX) ? Math.max(from - padding2, minX) : from - padding2, to: to + padding2 };
+};
+var createNormalCurve = (mu, sd, value, minX) => {
+  const { from, to } = curveRange(mu, sd, value, minX);
+  return Array.from({ length: curvePoints + 1 }, (_, index) => from + (to - from) * index / curvePoints).map((x) => ({
+    x,
+    y: normalPdf(x, mu, sd)
+  }));
+};
+var distributionAnnotations = (min, max, value, mean) => ({
+  ...Number.isFinite(min) && Number.isFinite(max) ? {
+    interval: {
+      type: "box",
+      xMin: min,
+      xMax: max,
+      backgroundColor: opaqueColor(colors.lightBlue, 0.3),
+      borderWidth: 0,
+      drawTime: "beforeDatasetsDraw"
+    }
+  } : {},
+  ...Number.isFinite(mean) ? {
+    mean: {
+      type: "line",
+      xMin: mean,
+      xMax: mean,
+      borderColor: colors.lightBlue,
+      borderWidth: 1,
+      borderDash: [4, 4],
+      label: {
+        display: true,
+        content: "average",
+        position: "start",
+        backgroundColor: colors.lightBlue,
+        color: colors.darkBlue,
+        font: { size: 9 }
+      }
+    }
+  } : {},
+  ...Number.isFinite(value) ? {
+    value: {
+      type: "line",
+      xMin: value,
+      xMax: value,
+      borderColor: colors.orange,
+      borderWidth: 2,
+      label: {
+        display: true,
+        content: `${formatPrecision(value, 3, true)}`,
+        position: "start",
+        backgroundColor: colors.orange,
+        color: "#fff",
+        font: { size: 10 }
+      }
+    }
+  } : {}
+});
+var createSinglePointDataset = (labels, pointValue) => {
+  const pointData = new Array(labels.length).fill(null);
+  const binIndex = labels.findIndex((label) => {
+    const [minStr, maxStr] = label.split(joinXLabel);
+    const binMin = parseFloat(minStr);
+    const binMax = parseFloat(maxStr);
+    return pointValue >= binMin && pointValue < binMax;
+  });
+  if (binIndex !== -1) {
+    pointData[binIndex] = 1;
+  }
+  return pointData;
+};
+var histogramConfig = (label) => ({
+  options: {
+    scales: {
+      x: {
+        display: true,
+        grid: {
+          offset: true
+        },
+        min: 0,
+        ticks: {
+          callback: function(value) {
+            var _a, _b, _c;
+            const tickLabel = this.getLabelForValue(value);
+            return (_c = (_b = (_a = tickLabel == null ? void 0 : tickLabel.split(joinXLabel)) == null ? void 0 : _a.map(parseFloat)) == null ? void 0 : _b.map((v) => formatPrecision(v, 3, true))) == null ? void 0 : _c.join("-");
+          }
+        },
+        title: {
+          display: true,
+          text: label
+        }
+      },
+      y: {
+        ticks: {
+          font: {
+            family: defaultTicksFont.family,
+            size: 10,
+            weight: 400
+          },
+          color: "#4A4A4A"
+        },
+        title: {
+          display: true,
+          text: "Frequency of values"
+        }
+      }
+    }
+  }
+});
+var parametricConfig = ({ label, intervalMin, intervalMax, value, mu }) => ({
+  options: {
+    plugins: {
+      annotation: {
+        annotations: distributionAnnotations(intervalMin, intervalMax, value, mu)
+      }
+    },
+    scales: {
+      x: {
+        type: "linear",
+        display: true,
+        ticks: {
+          font: {
+            family: defaultTicksFont.family,
+            size: 10,
+            weight: 400
+          },
+          color: "#4A4A4A",
+          callback: (tick) => `${formatPrecision(tick, 3, true)}`
+        },
+        title: {
+          display: true,
+          text: label
+        }
+      },
+      y: {
+        // the density itself carries no meaning for the reader, only the shape does
+        ticks: {
+          display: false
+        },
+        grid: {
+          display: false
+        },
+        title: {
+          display: false
+        }
+      }
+    }
+  }
+});
+var withinPercentile = (distribution = [], maxPercentile = 0) => {
+  const limit = maxPercentile ? utils.getPercentileValue(distribution, maxPercentile) : null;
+  return limit ? distribution.filter((v) => v <= limit) : distribution;
+};
+var histogramDatasets = (frequencies) => [
+  {
+    label: "Distribution",
+    data: frequencies,
+    backgroundColor: opaqueColor(colors.lightBlue),
+    borderColor: colors.lightBlue,
+    borderWidth: 1,
+    type: "bar"
+  },
+  {
+    label: "Distribution",
+    data: frequencies,
+    backgroundColor: opaqueColor(colors.darkBlue),
+    borderColor: colors.darkBlue,
+    borderWidth: 1,
+    fill: false,
+    pointRadius: 0,
+    type: "line"
+  }
+];
+var valueDataset = (singlePoint) => (singlePoint == null ? void 0 : singlePoint.length) ? [
+  {
+    label: "Value",
+    data: singlePoint,
+    fill: false,
+    borderColor: colors.darkBlue,
+    backgroundColor: colors.darkBlue,
+    pointRadius: 4,
+    showLine: false,
+    type: "line",
+    tension: 0
+  }
+] : [];
+var histogramData = ({ distribution, value, nbBins = 10, maxPercentile = 0 }) => {
+  const grouped = createDynamicHistogramData(withinPercentile(distribution, maxPercentile), nbBins);
+  return {
+    datasets: [
+      ...distribution ? histogramDatasets(grouped.frequencies) : [],
+      ...valueDataset(createSinglePointDataset((grouped == null ? void 0 : grouped.labels) || [], value))
+    ],
+    labels: grouped.labels
+  };
+};
+var parametricData = ({ mu, sd, value, minX }) => ({
+  datasets: [
+    {
+      label: "Distribution",
+      data: createNormalCurve(mu, sd, value, minX),
+      backgroundColor: opaqueColor(colors.lightBlue, 0.2),
+      // light enough to read on a dark panel, dark enough to read on a white one
+      borderColor: colors.lightBlue,
+      borderWidth: 1,
+      fill: true,
+      pointRadius: 0,
+      type: "line"
+    }
+  ]
+});
+var isParametric = ({ mu, sd }) => Number.isFinite(mu) && Number.isFinite(sd) && sd > 0;
+var distributionChart = (inputs) => {
+  var _a;
+  const label = (_a = inputs.label) != null ? _a : "Distribution";
+  return isParametric(inputs) ? {
+    data: parametricData(inputs),
+    config: merge__default.default({}, defaultDistributionSettings, parametricConfig({ ...inputs, label }))
+  } : {
+    data: histogramData(inputs),
+    config: merge__default.default({}, defaultDistributionSettings, histogramConfig(label))
+  };
+};
+
+// src/charts/download.ts
+var downloadFile = (url, fileName) => {
+  if (!url) {
+    return;
+  }
+  const a = document.createElement("a");
+  document.body.appendChild(a);
+  a.setAttribute("style", "display: none");
+  a.href = url;
+  a.download = fileName;
+  a.click();
+  a.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 100);
+};
+var data = emissionGroupings__default.default;
+var categoryLabel = (key) => key ? utils.keyToLabel(key.replace(/category/gi, "")) : "Unset";
+var emissionCategories = Object.keys(data).filter((key) => key.toLowerCase().endsWith("category")).map((key) => ({ key, label: categoryLabel(key) }));
+var categoryValues = (category) => data[category];
+var emissionCategoriesOf = (emissionId) => Object.keys(data[emissionId]).filter((key) => !!data[emissionId][key]);
+var emissionCategoryValue = (emissionId, category) => {
+  var _a;
+  return (_a = data[emissionId]) == null ? void 0 : _a[category];
+};
+var defaultChartWidth = 800;
+var defaultChartHeight = 600;
+var extractEssentialChartConfig = (config) => {
+  var _a, _b;
+  return {
+    type: config.type || "bar",
+    data: config.data,
+    options: {
+      indexAxis: (_a = config.options) == null ? void 0 : _a.indexAxis,
+      responsive: false,
+      maintainAspectRatio: false,
+      devicePixelRatio: 1,
+      animation: false,
+      animations: {
+        colors: false,
+        x: false,
+        y: false
+      },
+      transitions: {
+        active: {
+          animation: {
+            duration: 0
+          }
+        }
+      },
+      plugins: {
+        legend: { display: false },
+        title: ((_b = config.options.plugins) == null ? void 0 : _b.title) || { display: false }
+      },
+      scales: config.options.scales
+    }
+  };
+};
+var stretchSvg = (svgString, width2, height) => {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(svgString, "image/svg+xml");
+  const svgElement = doc.documentElement;
+  svgElement.setAttribute("viewBox", `0 0 ${width2 + 100} ${height}`);
+  svgElement.setAttribute("width", "100%");
+  svgElement.setAttribute("height", "100%");
+  svgElement.setAttribute("preserveAspectRatio", "xMidYMid meet");
+  return svgElement.outerHTML;
+};
+var parseAfterDrawBarPlugins = (afterBarDrawConfig, units) => Array.isArray(afterBarDrawConfig) ? afterBarDrawConfig.map(afterBarDrawPlugin) : [
+  afterBarDrawPlugin({
+    textFn: ({ data: data2 }) => [utils.toPrecision(Array.isArray(data2) ? data2[0] : data2), units].filter(Boolean).join(" "),
+    emptyValueLabel: "No data",
+    ...afterBarDrawConfig || {}
+  })
+];
+var convertToSvg = (config, metadata = {}) => new Promise((resolve, reject) => {
+  const width2 = metadata.width || defaultChartWidth;
+  const height = metadata.height || defaultChartHeight;
+  const svgContext = new C2S__default.default(width2, height);
+  svgContext.setTransform = () => {
+  };
+  svgContext.resetTransform = () => {
+  };
+  svgContext.roundRect = function(x, y, w, h) {
+    this.rect(x, y, w, h);
+  };
+  const mockCanvas = document.createElement("canvas");
+  mockCanvas.width = width2;
+  mockCanvas.height = height;
+  mockCanvas.style.width = `${width2}px`;
+  mockCanvas.style.height = `${height}px`;
+  mockCanvas.getBoundingClientRect = () => ({
+    x: 0,
+    y: 0,
+    bottom: height,
+    height,
+    left: 0,
+    right: width2,
+    top: 0,
+    width: width2,
+    toJSON: () => {
+    }
+  });
+  mockCanvas.getContext = (type) => {
+    if (type === "2d") {
+      svgContext.canvas = mockCanvas;
+      return svgContext;
+    }
+    return null;
+  };
+  const chartConfig = extractEssentialChartConfig(config);
+  let chart;
+  chartConfig.options.animation = {
+    onComplete: () => {
+      try {
+        const svgString = svgContext.getSerializedSvg(true);
+        const finalSvg = stretchSvg(svgString, width2, height);
+        chart.destroy();
+        resolve(finalSvg);
+      } catch (e) {
+        reject(e);
+      }
+    }
+  };
+  chartConfig.plugins = [
+    metadata.afterBarDrawConfig !== null && parseAfterDrawBarPlugins(metadata.afterBarDrawConfig, metadata.units),
+    metadata.lollipopConfig !== null && lollipopChartPlugin(metadata.lollipopConfig)
+  ].filter(Boolean).flat();
+  chart = new chart_js.Chart(mockCanvas, chartConfig);
+});
+var exportAsSVG = async (config, metadata) => {
+  try {
+    const content = await convertToSvg(config, metadata);
+    const blob = new Blob([content], { type: "image/svg+xml;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    downloadFile(url, metadata.fileName || "chart-export.svg");
+  } catch (error) {
+    console.error("Failed to export SVG", error);
+  }
+};
+var svgToUrl = (svgElement) => {
+  const serializer = new XMLSerializer();
+  let svgString = serializer.serializeToString(svgElement);
+  if (!svgString.includes("xmlns")) {
+    svgString = svgString.replace(/^<svg/, '<svg xmlns="http://www.w3.org/2000/svg"');
+  }
+  const blob = new Blob([svgString], { type: "image/svg+xml;charset=utf-8" });
+  return URL.createObjectURL(blob);
+};
+var downloadSvg = (svgElement) => downloadFile(svgToUrl(svgElement), "chart.svg");
+var downloadPng = async (svgElement, { width: width2, height } = {}) => {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  const img = new Image();
+  const svgSize = svgElement.getBoundingClientRect();
+  canvas.width = width2 || svgSize.width;
+  canvas.height = height || svgSize.height;
+  img.onload = () => {
+    if (ctx) {
+      ctx.fillRect(0, 0, canvas.width, canvas.height);
+      ctx.drawImage(img, 0, 0);
+      const pngUrl = canvas.toDataURL("image/png");
+      downloadFile(pngUrl, "chart.png");
+    }
+  };
+  img.src = svgToUrl(svgElement);
+};
+var ChartNodeType = /* @__PURE__ */ ((ChartNodeType2) => {
+  ChartNodeType2["midpoint"] = "midpoint";
+  ChartNodeType2["category"] = "category";
+  ChartNodeType2["emission"] = "emission";
+  ChartNodeType2["endpoint"] = "endpoint";
+  ChartNodeType2["input"] = "input";
+  ChartNodeType2["operation"] = "operation";
+  ChartNodeType2["root"] = "root";
+  return ChartNodeType2;
+})(ChartNodeType || {});
+var nodeBorderColours = {
+  ["endpoint" /* endpoint */]: "#193957",
+  ["midpoint" /* midpoint */]: "#249DA5",
+  ["category" /* category */]: "#DC7033",
+  ["emission" /* emission */]: "#498F78",
+  ["input" /* input */]: "#FFC000",
+  ["operation" /* operation */]: "#D0CABA"
+};
+var nodeColours = {
+  ["endpoint" /* endpoint */]: "#DBE3EA",
+  ["midpoint" /* midpoint */]: "#D3EBED",
+  ["category" /* category */]: "#FFDEC0",
+  ["emission" /* emission */]: "#D5F3D8",
+  ["input" /* input */]: "#FFE8A3",
+  ["operation" /* operation */]: "#FBF4DF"
+};
+var legend = [
+  { type: "endpoint" /* endpoint */, text: "Endpoint / Single Score" },
+  { type: "midpoint" /* midpoint */, text: "Characterised Indicator" },
+  { type: "category" /* category */, text: "Category" },
+  { type: "emission" /* emission */, text: "Emission / Resource Use" },
+  { type: "input" /* input */, text: "Input" },
+  { type: "operation" /* operation */, text: "Operation" }
+];
+var getUnitsAndLabel = (terms, fallbackLabel = "unknown term") => {
+  var _a, _b;
+  const allTerms = (Array.isArray(terms) ? terms : [terms]).filter(Boolean);
+  const term2 = allTerms == null ? void 0 : allTerms[0];
+  const label = (_b = (_a = term2 == null ? void 0 : term2.name) != null ? _a : term2 == null ? void 0 : term2["@id"]) != null ? _b : fallbackLabel;
+  const units = (term2 == null ? void 0 : term2.units) ? `(${term2 == null ? void 0 : term2.units})` : "";
+  return {
+    label: `${label.replace(units, "").trim()}${allTerms.length > 1 ? ` (and ${allTerms.length - 1} more)` : ""}`,
+    terms: allTerms,
+    units
+  };
+};
+var typeMapping = {
+  [schema.TermTermType.endpointIndicator]: "endpoint" /* endpoint */,
+  [schema.TermTermType.characterisedIndicator]: "midpoint" /* midpoint */,
+  [schema.TermTermType.emission]: "emission" /* emission */,
+  [schema.TermTermType.resourceUse]: "emission" /* emission */,
+  [schema.TermTermType.operation]: "operation" /* operation */
+};
+var safeDivide = (numerator, denominator) => denominator !== 0 ? numerator / denominator : 0;
+var sumIndicators = (data2) => {
+  const totalValues = data2.reduce(
+    (acc, log) => {
+      acc[log.indicator] = acc[log.indicator] || [];
+      !utils.isUndefined(log.weightedValue) && acc[log.indicator].push(log.weightedValue);
+      if (log.category) {
+        const categoryKey = `${log.indicator}-${log.category}`;
+        acc[categoryKey] = acc[categoryKey] || [];
+        !utils.isUndefined(log.weightedValue) && acc[categoryKey].push(log.weightedValue);
+      }
+      return acc;
+    },
+    {}
+  );
+  return Object.fromEntries(
+    Object.entries(totalValues).map(([key, values]) => [
+      key,
+      // if the total is positive, we ignore negative values
+      utils.sum(values) < 0 ? utils.sum(values) : utils.sum(values.filter((v) => v >= 0))
+    ])
+  );
+};
+var groupIndicators = (data2, terms = {}, totals = {}) => data2.reduce(
+  (acc, log) => {
+    var _a, _b;
+    const contributorType = typeMapping[(_a = terms[log.contributor]) == null ? void 0 : _a.termType] || "input" /* input */;
+    const indicatorType = typeMapping[(_b = terms[log.indicator]) == null ? void 0 : _b.termType];
+    const categoryKey = log.category ? `${log.indicator}-${log.category}` : void 0;
+    const parentTotal = categoryKey ? totals[categoryKey] : totals[log.indicator];
+    const contributorNode = {
+      id: log.contributor,
+      ...getUnitsAndLabel(terms[log.contributor], log.contributor),
+      type: contributorType,
+      value: log.value,
+      weightedValue: log.weightedValue,
+      modelId: log.modelId,
+      fraction: safeDivide(log.weightedValue, parentTotal),
+      children: contributorType === "emission" /* emission */ ? log.inputs.map((i) => ({
+        ...i,
+        ...getUnitsAndLabel(terms[i.id], i.label),
+        type: "input" /* input */,
+        fraction: safeDivide(i.weightedValue, log.value),
+        children: i.operations.map((o) => ({
+          ...o,
+          ...getUnitsAndLabel(terms[o.id], o.label),
+          type: "operation" /* operation */,
+          fraction: safeDivide(o.weightedValue, i.weightedValue)
+        }))
+      })) : []
+    };
+    acc[log.indicator] = acc[log.indicator] || {
+      id: log.indicator,
+      ...getUnitsAndLabel(terms[log.indicator], log.indicator),
+      modelId: log.modelId,
+      type: indicatorType,
+      value: totals[log.indicator],
+      children: []
+    };
+    if (log.category) {
+      const categoryId = `cat-${log.indicator}-${log.category}`;
+      let categoryNode = acc[log.indicator].children.find((c) => c.id === categoryId);
+      if (!categoryNode) {
+        categoryNode = {
+          id: categoryId,
+          label: log.category,
+          type: "category" /* category */,
+          units: "",
+          value: totals[categoryKey],
+          weightedValue: totals[categoryKey],
+          modelId: log.modelId,
+          fraction: safeDivide(totals[categoryKey], totals[log.indicator]),
+          children: []
+        };
+        acc[log.indicator].children.push(categoryNode);
+      }
+      categoryNode.children.push(contributorNode);
+    } else {
+      acc[log.indicator].children.push(contributorNode);
+    }
+    return acc;
+  },
+  {}
+);
+
+// src/charts/hierarchy/contributions.ts
+var hierarchyTermTypes = [
+  schema.TermTermType.resourceUse,
+  schema.TermTermType.emission,
+  schema.TermTermType.characterisedIndicator,
+  schema.TermTermType.endpointIndicator,
+  schema.TermTermType.model
+];
+var defaultIndicatorsModelId = "defaultIndicatorsModelId";
+var defaultIndicatorsModelName = "Default Indicators (multi-model)";
+var defaultModelId = (indicatorId) => defaultModelIds__default.default[indicatorId];
+var hierarchyWarnings = (logs, terms) => [!logs.every((log) => terms[log.indicator] && terms[log.contributor]) && "missing-terms"].filter(Boolean);
+var operationOf = (eru, modelId) => eru.operation ? [
+  {
+    id: eru.operation["@id"],
+    ...getUnitsAndLabel(eru.operation),
+    modelId,
+    weightedValue: eru.value
+  }
+] : [];
+var inputsOf = (impactAssessment, contributor, modelId) => Object.values(
+  (impactAssessment.emissionsResourceUse || []).filter((eru) => {
+    var _a;
+    return eru.term["@id"] === contributor && ((_a = eru.inputs) == null ? void 0 : _a.length);
+  }).reduce(
+    (acc, eru) => {
+      var _a;
+      const inputId = eru.inputs.map((i) => i["@id"]).join(";");
+      const operations = operationOf(eru, modelId);
+      return {
+        ...acc,
+        [inputId]: acc[inputId] ? {
+          ...acc[inputId],
+          weightedValue: acc[inputId].weightedValue + eru.value,
+          modelId,
+          operations: [...acc[inputId].operations, ...operations]
+        } : {
+          id: inputId,
+          ...!((_a = eru.inputs) == null ? void 0 : _a.length) ? { label: "Input group (under development)" } : getUnitsAndLabel(eru.inputs),
+          modelId,
+          weightedValue: eru.value,
+          operations
+        }
+      };
+    },
+    {}
+  )
+);
+var parseLogValues = (impactAssessment, values) => {
+  const log = values[0];
+  const weightedValue = values.reduce((total, curr) => total + curr.weightedValue, 0);
+  const value = values.reduce((total, curr) => total + curr.value, 0);
+  return {
+    ...log,
+    weightedValue,
+    value,
+    inputs: inputsOf(impactAssessment, log.contributor, log.modelId)
+  };
+};
+var processContributions = (record, nodes) => Object.entries(record || {}).flatMap(([index, byIndicator]) => {
+  const indicator = nodes[+index];
+  return indicator ? Object.entries(byIndicator).flatMap(
+    ([impactTermId, modelContr]) => Object.entries(modelContr).map(([modelId, weightedValue]) => {
+      const contributor = indicator.term["@id"];
+      const value = indicator.value || 0;
+      const coefficient = value !== 0 ? weightedValue / value : 0;
+      return coefficient > 0 ? { indicator: impactTermId, contributor, coefficient, modelId, weightedValue, value } : null;
+    })
+  ) : null;
+});
+var hierarchyContributions = (impactAssessment, stored) => {
+  const logs = [
+    ...processContributions(stored == null ? void 0 : stored.emissionsResourceUse, impactAssessment.emissionsResourceUse || []),
+    ...processContributions(stored == null ? void 0 : stored.impacts, impactAssessment.impacts || [])
+  ].filter(Boolean);
+  const grouped = logs.reduce(
+    (acc, log) => {
+      const key = [log.indicator, log.contributor, log.modelId].join("/");
+      return { ...acc, [key]: [...acc[key] || [], log] };
+    },
+    {}
+  );
+  return Object.values(grouped).map((values) => parseLogValues(impactAssessment, values));
+};
+var missingTermIds = (logs, terms = {}) => utils.unique(logs.flatMap((l) => {
+  var _a;
+  return [l.contributor, l.indicator, ...((_a = l.inputs) != null ? _a : []).map((i) => i.id)];
+}).filter((id) => !terms[id]));
+var hierarchyModels = (logs, terms) => [
+  ...logs.some((log) => log.modelId === defaultModelId(log.indicator)) ? [{ "@id": defaultIndicatorsModelId, name: defaultIndicatorsModelName }] : [],
+  ...utils.unique(logs.map(({ modelId }) => terms[modelId] || { "@id": modelId }))
+];
+var forModel = (log, modelId) => log.modelId === (modelId === defaultIndicatorsModelId ? defaultModelId(log.indicator) : modelId);
+var withCategory = (log, terms, category) => {
+  var _a;
+  const included = category && [schema.TermTermType.emission, schema.TermTermType.resourceUse].includes((_a = terms[log.contributor]) == null ? void 0 : _a.termType);
+  const label = category ? categoryLabel(category) : void 0;
+  return included ? {
+    ...log,
+    category: emissionCategoryValue(log.contributor, category) || `Not available for ${label}`,
+    categoryLabel: label
+  } : log;
+};
+var hierarchyData = (logs, terms, modelId, category) => logs.filter((log) => forModel(log, modelId)).map((log) => withCategory(log, terms, category));
 
-// src/charts/indicator-breakdown.ts
+// src/charts/hierarchy/data.ts
+var nonLCAIndicatorsId = "nonLCAIndicators";
+var childLabel = (indicator, child) => {
+  const prefixRemoved = indicator.type === "endpoint" /* endpoint */ && child.label.split(", ")[1];
+  return prefixRemoved ? "[...]" + prefixRemoved.charAt(0).toUpperCase() + prefixRemoved.slice(1) : child.label;
+};
+var linkIndicators = (indicators) => {
+  const all = Object.values(indicators);
+  return all.map((indicator) => ({
+    ...indicator,
+    children: indicator.children.map(
+      (child) => {
+        var _a, _b;
+        return child.type === "midpoint" /* midpoint */ ? {
+          ...child,
+          label: childLabel(indicator, child),
+          modelId: ((_a = indicators[child.id]) == null ? void 0 : _a.modelId) || child.modelId,
+          children: (_b = indicators[child.id]) == null ? void 0 : _b.children
+        } : child;
+      }
+    )
+  })).filter((indicator) => !all.some((parent) => parent.children.some((child) => child.id === indicator.id)));
+};
+var otherIndicators = (children) => children.length ? {
+  id: nonLCAIndicatorsId,
+  label: "Other indicators",
+  term: "n/a",
+  modelId: "n/a",
+  units: "",
+  value: null,
+  weightedValue: null,
+  type: "endpoint" /* endpoint */,
+  fraction: null,
+  children
+} : null;
+var hierarchyChildren = (data2, terms) => {
+  const linked = linkIndicators(groupIndicators(data2, terms, sumIndicators(data2)));
+  const endpoints = linked.filter((indicator) => indicator.type === "endpoint" /* endpoint */);
+  const midpoints = linked.filter((indicator) => indicator.type === "midpoint" /* midpoint */);
+  return endpoints.length ? [...endpoints, otherIndicators(midpoints)].filter(Boolean) : linked;
+};
+var hierarchyLegend = (data2, includedTypes) => {
+  var _a;
+  const shown = legend.filter(({ type }) => includedTypes.includes(type));
+  const categoryLabel2 = (_a = data2.find((d) => d.categoryLabel)) == null ? void 0 : _a.categoryLabel;
+  return categoryLabel2 ? shown.map((l) => l.type === "category" /* category */ ? { ...l, text: categoryLabel2 } : l) : shown;
+};
+var extraInputKeys = ["input", "input value"];
+var extraOperationKeys = ["operation", "operation value"];
+var dataToCsv = (keys, terms) => (data2) => {
+  var _a;
+  return [
+    // line for the data
+    toLine([
+      ...keys.map((k) => {
+        var _a2;
+        return ((_a2 = terms[data2[k]]) == null ? void 0 : _a2.name) || data2[k] || "";
+      }),
+      ...extraInputKeys.map(() => ""),
+      ...extraOperationKeys.map(() => "")
+    ]),
+    // lines for each inputs and operations
+    ...((_a = data2.inputs) != null ? _a : []).flatMap((input) => {
+      var _a2;
+      return [
+        toLine([...keys.map(() => ""), input.label, input.weightedValue, ...extraOperationKeys.map(() => "")]),
+        ...((_a2 = input.operations) != null ? _a2 : []).map(
+          (operation) => toLine([...keys.map(() => ""), ...extraInputKeys.map(() => ""), operation.label, operation.weightedValue])
+        )
+      ];
+    })
+  ];
+};
+var hierarchyCsv = (data2, terms) => {
+  const keys = Object.keys(data2[0]).filter((k) => k !== "inputs");
+  return [toLine([...keys, ...extraInputKeys, ...extraOperationKeys]), ...data2.flatMap(dataToCsv(keys, terms))].join(
+    "\n"
+  );
+};
+var width = 800;
+var margin = { top: 10, right: 20, bottom: 10, left: 20 };
+var fontSize = Math.floor(width / 100);
+var nodePadding = fontSize / 2;
+var lineHeight = fontSize * 1.2;
+var barHeight = lineHeight;
+var barRadius = 4;
+var nodeHeight = nodePadding * 2 + 2 * lineHeight + barHeight;
+var nodeWidth = nodeHeight * 2 * 1.618;
+var nodeContentWidth = nodeWidth - nodePadding * 2;
+var layerSpacing = (width - margin.left - margin.right - nodeWidth * 5) / 4;
+var nodeMargin = nodePadding * 0.75;
+var nodeSpacingFactor = (nodeHeight + nodeMargin * 2) / nodeHeight;
+var nodeDuration = 600;
+var linkDuration = 200;
+var groupDelay = nodeDuration - 100;
+var greyedOpacity = 0.2;
+var groupOverlap = lineHeight - nodePadding - nodeMargin;
+var groupNodeSpace = nodeHeight - 2 * groupOverlap;
+var collapseChildren = (node) => {
+  node._children = node.children || node._children;
+  node.children = null;
+  return node;
+};
+var restoreChildren = (node) => {
+  node.children = node._children;
+  node._children = null;
+  return node;
+};
+var childrenOf = (node) => (node == null ? void 0 : node.children) || (node == null ? void 0 : node._children) || [];
+var enterStagger = (parent, child) => Math.max(childrenOf(parent).indexOf(child), 0) * 10;
+var exitStagger = (parent, child) => {
+  const children = childrenOf(parent);
+  const index = children.indexOf(child);
+  return index < 0 ? 0 : (children.length - index - 1) * 10;
+};
+var wrap = (selection, maxWidth = nodeContentWidth) => {
+  selection.each(function(d) {
+    const t = d3Selection.select(this);
+    const units = utils.ellipsis(d.data.units, 20);
+    d3wrap(t, {
+      maxWidth,
+      maxLines: d.data.showBar ? 2 : 3,
+      vcentre: !d.data.showBar,
+      words: [...d.data.label.split(/\s+/), units],
+      ownLineWord: units,
+      nHeight: nodeHeight,
+      lHeight: lineHeight
+    });
+  });
+};
+var setNodeSize = (selection) => selection.attr("width", nodeWidth).attr("height", nodeHeight);
+var formatBar = (selection) => selection.attr("height", barHeight).attr("rx", `${barRadius}`).attr("ry", `${barRadius}`).attr("y", nodeHeight - nodePadding - barHeight).attr("x", nodePadding);
+var formatBarPath = (data2) => {
+  const x = nodePadding;
+  const y = nodeHeight - nodePadding - barHeight;
+  const h = barHeight;
+  const w = fractionWidth(data2);
+  const isFull = data2.fraction >= 0.99;
+  const safeW = data2.fraction < 0.01 ? 0 : Math.max(w, barRadius);
+  const safeH = Math.max(h, 2 * barRadius);
+  return isFull ? `
+    M ${x + safeW - barRadius}, ${y}
+    a ${barRadius},${barRadius} 0 0 1 ${barRadius},${barRadius} v ${safeH - 2 * barRadius}
+    a ${barRadius},${barRadius} 0 0 1 -${barRadius},${barRadius} h -${safeW - 2 * barRadius}
+    a ${barRadius},${barRadius} 0 0 1 -${barRadius},-${barRadius} v -${safeH - 2 * barRadius}
+    a ${barRadius},${barRadius} 0 0 1 ${barRadius},-${barRadius}
+    z
+  ` : `
+    M ${x + safeW}, ${y}
+    v ${safeH}
+    h -${safeW - barRadius}
+    a ${barRadius},${barRadius} 0 0 1 -${barRadius},-${barRadius}
+    v -${safeH - 2 * barRadius}
+    a ${barRadius},${barRadius} 0 0 1 ${barRadius},-${barRadius}
+    z
+  `;
+};
+var groupButtonWidth = nodeWidth * 2 / 7;
+var groupButtonHeight = nodePadding * 2 + lineHeight + 3;
+var setGroupButtonXY = (selection) => selection.attr("width", groupButtonWidth).attr("height", (d) => d._groupOpen ? lineHeight + nodePadding * 2 : groupButtonHeight).attr("x", (d) => d._groupOpen ? nodeWidth * 2.5 / 7 : nodeWidth / 2 - groupButtonWidth / 2).attr(
+  "y",
+  (d) => d._groupOpen ? groupOverlap + (groupNodeSpace - (lineHeight + nodePadding * 2)) / 2 : nodePadding + lineHeight + 6
+);
+var formatNumber = (value) => utils.isNumber(value) ? utils.toPrecision(value, 3) : "N/A";
+var isTypeWithoutValue = (nodeDatum) => ["input" /* input */, "operation" /* operation */].includes(nodeDatum.data.type);
+var getWeightedValueText = (nodeDatum) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  return `${formatNumber(nodeDatum.data.weightedValue)}${((_a = nodeDatum.parent) == null ? void 0 : _a.data.value) === null ? "" : ` of ${formatNumber(((_b = nodeDatum.parent) == null ? void 0 : _b.data.value) || ((_c = nodeDatum.parent) == null ? void 0 : _c.data.weightedValue) || 0)}`} ${utils.isNumber((_d = nodeDatum.parent) == null ? void 0 : _d.data.value) ? (_f = (_e = nodeDatum.parent) == null ? void 0 : _e.data) == null ? void 0 : _f.units : (_i = (_h = (_g = nodeDatum.parent) == null ? void 0 : _g.parent) == null ? void 0 : _h.data) == null ? void 0 : _i.units}`;
+};
+var generateTipData = (nodeDatum, { baseUrl, schemaBaseUrl }) => {
+  var _a;
+  return {
+    hasWeightedValue: nodeDatum.data.weightedValue,
+    weightedValueText: getWeightedValueText(nodeDatum),
+    valueKeyHref: `${schemaBaseUrl()}/${schema.SchemaType.Indicator}#value`,
+    modelDocsHref: nodeDatum.data.modelDocs,
+    valueValueText: utils.isNumber(nodeDatum.data.value) ? `${formatNumber(nodeDatum.data.value)} ${nodeDatum.data.units}` : isTypeWithoutValue(nodeDatum) ? "" : "no contribution",
+    hasValue: nodeDatum.data.value,
+    modelKeyHref: `${schemaBaseUrl()}/${schema.SchemaType.Indicator}#methodModel`,
+    modelValue: nodeDatum.data.modelName,
+    modelValueHref: `${baseUrl()}/term/${nodeDatum.data.modelId}`,
+    termKeyHref: `${schemaBaseUrl()}/${schema.SchemaType.Indicator}#term`,
+    terms: (_a = nodeDatum.data.terms) == null ? void 0 : _a.map((term2) => ({
+      text: term2.name || term2["@id"],
+      href: `${baseUrl()}/term/${term2["@id"]}`
+    }))
+  };
+};
+var addTooltip = (selection, { tooltip, urls }) => {
+  let hoveringTip = false;
+  let hoveringNode = false;
+  let lastNodeId;
+  const closeTip = () => {
+    tooltip.close();
+    d3Selection.selectAll(".tip-target").classed("tip-target", false);
+    lastNodeId = null;
+  };
+  const startCloseTip = () => {
+    setTimeout(() => {
+      if (!hoveringTip && !hoveringNode) {
+        closeTip();
+      }
+    }, 100);
+  };
+  selection.on("click", closeTip).on("pointerenter", (event, nodeDatum) => {
+    hoveringNode = true;
+    if (lastNodeId === nodeDatum.data.id) {
+      return;
+    }
+    closeTip();
+    lastNodeId = nodeDatum.data.id;
+    d3Selection.select(event.target).classed("tip-target", true);
+    tooltip.open(generateTipData(nodeDatum, urls), event.target);
+    d3Selection.select(tooltip.element()).on("pointerenter", () => {
+      hoveringTip = true;
+    }).on("pointerleave", () => {
+      hoveringTip = false;
+      startCloseTip();
+    });
+  }).on("pointerleave", () => {
+    hoveringNode = false;
+    startCloseTip();
+  });
+  return selection;
+};
+var mergedNodes = (selection, options) => {
+  selection.selectAll(".node-box").classed("node-openable", (d) => !!d.height).classed("node-open", (d) => d._open).call(setNodeSize).attr("stroke", ({ data: data2 }) => nodeBorderColours[data2.type]).attr("fill", (d) => nodeColours[d.data.type]).attr("stroke-width", "2").attr("rx", "3px").attr("ry", "3px").style("user-select", typeof window !== "undefined" && window.innerWidth < 768 ? "none" : null);
+  selection.filter((d) => !d.data.group && d.data.id !== nonLCAIndicatorsId).call(addTooltip, options);
+  selection.selectAll(".node-label").attr("y", (d) => d.data.showBar ? lineHeight / 2 + nodePadding / 2 : 0).attr("x", nodeWidth / 2).attr("font-weight", "bold").attr("fill", "#4a4a4a").attr("text-anchor", "middle").attr("alignment-baseline", "central");
+  const groups = selection.filter((d) => d.data.group);
+  groups.selectAll(".group-border").attr("width", nodeWidth + nodePadding * 2).attr("x", -nodePadding).attr("y", nodeHeight - (lineHeight + nodePadding * 2)).attr("opacity", (d) => d._greyed && d._groupOpen ? greyedOpacity : d._groupOpen ? 1 : 0).attr(
+    "height",
+    (d) => d._groupOpen ? Math.abs(d.parent._groupChildren.length - d.parent.children.length) * (nodeHeight * nodeSpacingFactor) + nodePadding + (lineHeight + nodePadding * 2) / 2 : 0
+  ).attr("fill", "none").attr("stroke-dasharray", "2, 5").attr("stroke", "#b5b5b5").attr("stroke-width", "1");
+  groups.selectAll(".group-label").attr("width", nodeWidth).attr("y", nodeHeight / 3).attr("x", nodeWidth / 2).text((d) => d.data.label).attr("opacity", (d) => d._groupOpen ? 0 : d._greyed ? greyedOpacity : 1).attr("fill", "#4a4a4a").attr("text-anchor", "middle").attr("alignment-baseline", "central").attr("font-weight", "bold");
+  groups.selectAll(".group-button-border").attr("width", nodeWidth).attr("x", 0).attr("y", 0).attr("height", (d) => d._groupOpen ? "0" : "45").attr("fill", "none").attr("stroke-dasharray", "2, 5").attr("stroke", "#b5b5b5").attr("stroke-width", "1");
+  groups.selectAll(".group-button").call(setGroupButtonXY).style("pointer-events", (d) => d._greyed ? "none" : "auto").style("stroke-opacity", (d) => d._greyed ? greyedOpacity : 1).style("display", "none").attr("fill", (d) => nodeColours[d.data.type]).attr("rx", "3px").attr("ry", "3px");
+  groups.selectAll(".group-button-text").text((d) => d._groupOpen ? "Hide" : "Show").style("display", "none").attr("x", (d) => d._groupOpen ? nodeWidth / 2 : nodeWidth / 2).attr("y", (d) => d._groupOpen ? nodeMargin + lineHeight + lineHeight / 2 : nodeHeight / 3 + groupButtonHeight - 4).attr("font-size", () => `${fontSize * 1.3}px`).attr("fill", "#4a4a4a").attr("text-anchor", "middle").attr("alignment-baseline", "central");
+  selection.selectAll(".sibling-mask").remove();
+  selection.filter((d) => d._greyed && !d.data.group).append("rect").classed("node-openable", (d) => !!d.height).classed("sibling-mask mask-openable", true).attr("fill", "rgba(250, 250, 250)").attr("stroke", "rgba(250, 250, 250)").attr("fill-opacity", "0.8").attr("stroke-opacity", "0.9").attr("stroke-width", "2").attr("rx", "3px").attr("ry", "3px").call(setNodeSize);
+  selection.filter((d) => d._greyed && d.data.group).append("rect").classed("sibling-mask", true).attr("fill", "rgba(250, 250, 250)").attr("stroke", "rgba(250, 250, 250)").attr("fill-opacity", "0.8").attr("stroke-opacity", "0.9").attr("stroke-width", "2").attr("rx", "3px").attr("ry", "3px").call(setGroupButtonXY);
+  return selection;
+};
+var fractionCutoff = 0.7;
+var fractionWidth = (data2) => Math.min(Math.abs(data2.fraction), 1) * nodeContentWidth;
+var enterNodes = (selection) => {
+  const nodes = selection.filter((d) => d.data.type !== "root" /* root */ && !d.data.group);
+  nodes.append("rect").classed("node-box", true);
+  nodes.append("text").classed("node-label", true).text(({ data: data2 }) => data2.label + " " + data2.units).attr("opacity", 0);
+  setTimeout(() => {
+    const labels = nodes.selectAll(".node-label").call(wrap);
+    labels.attr("opacity", 1);
+  });
+  const groups = selection.filter((d) => d.data.group);
+  groups.append("rect").attr("class", "group-border");
+  groups.append("text").attr("class", "group-label");
+  groups.append("rect").attr("class", "group-button-border");
+  groups.append("rect").attr("class", "group-button");
+  groups.append("text").attr("class", "group-button-text");
+  const withBar = nodes.filter((d) => d.data.showBar);
+  withBar.filter((d) => d.data.fraction > 0).append("rect").classed("bar-background", true).attr("width", nodeContentWidth).attr("fill", "white").call(formatBar);
+  withBar.append("path").classed("bar-foreground", true).attr("d", (d) => formatBarPath(d.data)).attr("fill", (d) => nodeBorderColours[d.data.type]);
+  withBar.append("text").classed("bar-label", true).text(
+    ({ data: data2 }) => data2.fraction === 0 ? "no contribution" : `${Math.round(100 * data2.fraction)}% ${Math.round(100 * data2.fraction) === 0 ? " (rounded)" : ""}`
+  ).attr("text-anchor", (d) => d.data.fraction === 0 ? "middle" : d.data.fraction > fractionCutoff ? "end" : "start").attr(
+    "x",
+    (d) => d.data.fraction === 0 ? nodeWidth / 2 : fractionWidth(d.data) + nodePadding + (d.data.fraction > fractionCutoff ? -4 : 4)
+  ).attr("y", nodeHeight - nodePadding - barHeight / 2).attr("fill", "#4a4a4a").attr("alignment-baseline", "central");
+  return selection;
+};
+var mergedLinks = (selection, { togglingGroup, switchingSelection }) => selection.style("stroke", (d) => d.target._open && nodeBorderColours[d.source.data.type] || null).attr("stroke-dasharray", (d) => d.target.data.group ? "2,5" : null).attr("stroke-width", (d) => d.target._open ? 2 : d.target._groupOpen ? 0 : 1).attr("stroke-opacity", (d) => d.target._greyed ? 0.1 : 0.6).transition().duration(linkDuration).delay((d) => {
+  var _a;
+  const groupClosing = togglingGroup && !((_a = childrenOf(d.target.parent).find((n) => n.data.group)) == null ? void 0 : _a._groupOpen);
+  return groupClosing ? groupDelay : (switchingSelection ? nodeDuration : 0) + enterStagger(d.source, d.target);
+}).attr("opacity", 1).attr("d", (d) => {
+  const targetDy = d.target._groupOpen ? nodePadding + lineHeight / 2 + nodeMargin * 2 : nodeHeight / 2;
+  return d3Shape.linkHorizontal()({
+    source: [d.source.y + nodeWidth, d.source.x + nodeHeight / 2],
+    target: [d.target.y, d.target.x + targetDy]
+  });
+});
+var groupByPercentage = (node) => ["endpoint" /* endpoint */, "midpoint" /* midpoint */, "emission" /* emission */].includes(node.data.type);
+var groupPercentage = (node, percentage = 0.02) => {
+  var _a, _b, _c;
+  const grouped = (_a = node._children) == null ? void 0 : _a.filter((child) => child.data.fraction < percentage);
+  if (((_b = node._children) == null ? void 0 : _b.length) > 6 && (grouped == null ? void 0 : grouped.length) > 1) {
+    const type = node._children[0].data.type;
+    const groupNode = {
+      ...d3Hierarchy.hierarchy({
+        id: `${type}-group`,
+        label: `${grouped.length} more under ${Math.round(percentage * 100)}%.`,
+        weightedValue: null,
+        value: null,
+        type,
+        group: true
+      }),
+      depth: node.depth + 1,
+      height: 1,
+      parent: node
+    };
+    const notGrouped = (_c = node._children) == null ? void 0 : _c.filter((child) => child.data.fraction >= percentage);
+    node._children.splice(notGrouped.length, 0, groupNode);
+    notGrouped.push(groupNode);
+    node._groupChildren = node._children;
+    node._children = notGrouped;
+  }
+};
+var showBar = (node) => {
+  var _a, _b;
+  return [
+    ((_a = node.parent) == null ? void 0 : _a.data.type) !== "root" /* root */,
+    ((_b = node.parent) == null ? void 0 : _b.data.id) !== nonLCAIndicatorsId,
+    !node.data.group,
+    !isNaN(node.data.fraction)
+  ].every(Boolean);
+};
+var totalWidthFor = (numLayers) => {
+  const chartWidth = numLayers * nodeWidth + (numLayers - 1) * layerSpacing;
+  return { chartWidth, totalWidth: Math.max(width, chartWidth + margin.left + margin.right) };
+};
+var hierarchyOf = (children) => d3Hierarchy.hierarchy({
+  id: "dummy-root",
+  label: "",
+  terms: [],
+  modelId: "",
+  value: null,
+  weightedValue: null,
+  units: "",
+  type: "root" /* root */,
+  children
+});
+var prepareRoot = (root, terms) => root.sort((a, b) => (b.data.fraction || -Infinity) - (a.data.fraction || -Infinity)).eachAfter((node) => {
+  var _a, _b;
+  if (node.data.fraction === 0) {
+    node.children = null;
+    node.height = 0;
+  }
+  node.data.type !== "root" /* root */ && collapseChildren(node);
+  groupByPercentage(node) && groupPercentage(node);
+  node.data.showBar = showBar(node);
+  node.data.modelName = (_a = terms == null ? void 0 : terms[node.data.modelId]) == null ? void 0 : _a.name;
+  node.data.modelDocs = (_b = terms == null ? void 0 : terms[node.data.modelId]) == null ? void 0 : _b.docs;
+});
+var drawHierarchyChart = (svgElement, { data: data2, terms, tooltip, urls }) => {
+  const tree = hierarchyOf(hierarchyChildren(data2, terms));
+  const includedTypes = utils.unique(tree.descendants().map((n) => n.data.type));
+  const root = prepareRoot(tree, terms);
+  const numLayers = hierarchyLegend(data2, includedTypes).length;
+  const { chartWidth, totalWidth } = totalWidthFor(numLayers);
+  const svg = d3Selection.select(svgElement);
+  svg.selectAll("*").remove();
+  const innerHeight = (root.children.length - 1) * nodeHeight * nodeSpacingFactor + nodeHeight;
+  const yMin = (nodeHeight - innerHeight) / 2 - margin.top;
+  const yTotal = innerHeight + margin.top + margin.bottom;
+  svg.attr("viewBox", [-20, yMin, totalWidth, yTotal].join(" ")).attr("font-size", `${fontSize}px`);
+  let node = svg.append("g").selectAll("g");
+  let link = svg.append("g").selectAll("path");
+  const updateChart = ({ togglingGroup = false, switchingSelection = false } = {}) => {
+    const treeLayout = d3Hierarchy.tree().nodeSize([nodeHeight, nodeWidth]).separation(
+      (...neighbours) => neighbours.some((n) => n.data.group && n._groupOpen) ? 1 - groupOverlap / nodeHeight : nodeSpacingFactor
+    );
+    const tree2 = treeLayout(root);
+    const links = tree2.links().filter((d) => d.source.data.type !== "root" /* root */) || [];
+    const nodes = tree2.descendants().reverse();
+    const offset = Math.max(0, (totalWidth - margin.left - margin.right - chartWidth) / 2);
+    nodes.forEach((d) => {
+      d.y = offset + (d.depth - 1) * (nodeWidth + layerSpacing);
+    });
+    const minimiseHeight = ({ previousTanslateY, previousYTotal }, depth) => {
+      var _a, _b, _c;
+      const maxYTotal = Math.max(previousYTotal, yTotal);
+      const parent = tree2.find((n) => n.depth === depth - 1 && n._open);
+      (_a = parent == null ? void 0 : parent.children) == null ? void 0 : _a.forEach((n) => n.x += previousTanslateY);
+      const { min: minX, max: maxX } = ((parent == null ? void 0 : parent.children) || []).reduce(
+        ({ min, max }, n) => ({
+          min: n.x < min ? n.x : min,
+          max: n.x > max ? n.x : max
+        }),
+        { min: parent == null ? void 0 : parent.x, max: parent == null ? void 0 : parent.x }
+      );
+      const { yMin: childrenYMin, yTotal: childrenYTotal } = ((_b = parent == null ? void 0 : parent.children) == null ? void 0 : _b.length) ? { yMin: minX - margin.top, yTotal: maxX - minX + margin.bottom + margin.top + nodeHeight } : { yMin: null, yTotal: null };
+      const overflowAbove = yMin - childrenYMin;
+      const overflowBelow = childrenYTotal + childrenYMin - (maxYTotal + yMin);
+      const translateY = overflowAbove > 0 ? overflowAbove : overflowBelow > 0 ? Math.max(-overflowBelow, overflowAbove) : 0;
+      (_c = parent == null ? void 0 : parent.children) == null ? void 0 : _c.forEach((n) => n.x += translateY);
+      return {
+        previousYTotal: Math.max(childrenYTotal, previousYTotal),
+        previousTanslateY: translateY + previousTanslateY
+      };
+    };
+    const depths = Array.from({ length: numLayers }, (_, i) => i + 2);
+    const { previousYTotal: newHeight } = depths.reduce(minimiseHeight, {
+      previousTanslateY: 0,
+      previousYTotal: yTotal
+    });
+    svg.transition().duration(300).attr("viewBox", [-20, yMin, totalWidth, newHeight].join(" "));
+    node = node.data(
+      nodes.filter((d) => d.data.type !== "root" /* root */),
+      (d) => {
+        var _a, _b, _c, _d, _e, _f;
+        return `${(_c = (_b = (_a = d.parent) == null ? void 0 : _a.parent) == null ? void 0 : _b.parent) == null ? void 0 : _c.data.id}-${(_e = (_d = d.parent) == null ? void 0 : _d.parent) == null ? void 0 : _e.data.id}-${(_f = d.parent) == null ? void 0 : _f.data.id}-${d.data.id}`;
+      }
+    ).join(
+      (enter) => enter.append("g").call(enterNodes).attr("opacity", 0).attr("transform", (d) => "translate(" + (togglingGroup ? d.y : d.y - nodeWidth / 2) + "," + d.x + ")"),
+      (update) => update,
+      (exit) => {
+        tooltip.close();
+        return exit.style("pointer-events", "none").transition().duration(nodeDuration / 2).delay((d) => exitStagger(d.parent, d)).ease(d3Ease.easeElasticIn.amplitude(0.5).period(1)).attr("transform", (d) => "translate(" + (togglingGroup ? d.y : d.y - nodeWidth / 2) + "," + d.x + ")").attr("opacity", 0).remove().on("end", () => tooltip.close());
+      }
+    );
+    node.call(mergedNodes, { tooltip, urls }).transition().delay((d) => {
+      var _a;
+      const groupClosing = togglingGroup && !((_a = childrenOf(d.parent).find((n) => n.data.group)) == null ? void 0 : _a._groupOpen);
+      return groupClosing ? groupDelay : (switchingSelection ? nodeDuration : 0) + enterStagger(d.parent, d);
+    }).duration(nodeDuration).ease(d3Ease.easeElasticOut.amplitude(0.5).period(1)).attr("transform", (d) => `translate(${d.y},${d.x})`).attr("opacity", 1);
+    node.selectAll(".node-openable").on("click", handleNodeClick);
+    node.selectAll(".group-button").on("click", handleGroupButtonClick);
+    link = link.data(
+      links,
+      (d) => {
+        var _a, _b, _c;
+        return `${(_b = (_a = d.source.parent) == null ? void 0 : _a.parent) == null ? void 0 : _b.data.id}-${(_c = d.source.parent) == null ? void 0 : _c.data.id}-${d.source.data.id}-${d.target.data.id}`;
+      }
+    ).join(
+      (enter) => enter.append("path").classed("link-path", true).attr("opacity", 0).attr("fill", "none").attr("stroke", "#b5b5b5"),
+      (update) => update,
+      (exit) => exit.transition().duration(linkDuration / 2).delay((d) => exitStagger(d.source, d.target)).attr("opacity", 0).remove()
+    ).call(mergedLinks, { togglingGroup, switchingSelection });
+  };
+  const handleGroupButtonClick = (_event, d) => {
+    if (d._greyed) {
+      return;
+    }
+    d._groupOpen = !d._groupOpen;
+    const children = d.parent._groupChildren;
+    d.parent._groupChildren = d.parent.children;
+    d.parent.children = children;
+    updateChart({ togglingGroup: true });
+  };
+  const handleNodeClick = (_event, d) => {
+    d._open = !d._open;
+    const switchingSelection = "_greyed" in d && d._greyed;
+    childrenOf(d.parent).forEach((child) => {
+      child._greyed = false;
+      if (child !== d) {
+        child._open = false;
+        collapseChildren(child);
+        child._greyed = d._open;
+      }
+    });
+    d.children ? collapseChildren(d) : restoreChildren(d);
+    updateChart({ switchingSelection });
+  };
+  handleNodeClick(
+    null,
+    root.find((n) => n.depth === 1)
+  );
+  return { includedTypes };
+};
+var defaultHorizontalBarConfig = Object.freeze({
+  options: {
+    indexAxis: "y",
+    scales: {
+      x: {
+        grid: {
+          drawOnChartArea: false
+        },
+        ticks: {
+          callback: (value) => utils.toPrecision(Number(value), 3)
+        }
+      },
+      y: {
+        grid: {
+          drawOnChartArea: false
+        },
+        ticks: {
+          crossAlign: "near"
+        }
+      }
+    }
+  }
+});
+var defaultHorizontalTooltip = ({ label, count, includedItems }) => (includedItems == null ? void 0 : includedItems.length) ? includedItems.map(defaultHorizontalTooltip).join("</br>") : `${label}: ${count}`;
+var rowHeight = 40;
+var padding = 60;
+var horizontalBarHeight = (minHeight, maxHeight, nbRows) => Math.min(Math.max(nbRows * rowHeight + padding, minHeight), maxHeight);
 var logsTotalValue = (logs, includeNegativeValues = true) => utils.sum((includeNegativeValues ? logs : logs.filter((curr) => curr.value >= 0)).map((v) => v.value));
 var valueRatio = (value, total) => total === 0 ? 0 : utils.toPrecision(value * 100 / Math.abs(total), 2);
 var chartLabel = (value, total) => {
@@ -701,7 +2068,7 @@ var logToCsv = (logs, impact) => [
     }
   )
 ].join("\n");
-var processContributions = (record, nodes, impacts) => Object.entries(record || {}).flatMap(([index, impactContr]) => {
+var processContributions2 = (record, nodes, impacts) => Object.entries(record || {}).flatMap(([index, impactContr]) => {
   const indicator = nodes[+index];
   return indicator ? Object.entries(impactContr).flatMap(([impactTermId, modelContr]) => {
     const impact = impacts == null ? void 0 : impacts.find((v) => v.term["@id"] === impactTermId);
@@ -721,12 +2088,12 @@ var processContributions = (record, nodes, impacts) => Object.entries(record ||
   }) : null;
 });
 var parseContributions = (impactAssessment, contributions) => [
-  ...processContributions(
+  ...processContributions2(
     contributions == null ? void 0 : contributions.emissionsResourceUse,
     impactAssessment.emissionsResourceUse || [],
     (impactAssessment == null ? void 0 : impactAssessment.impacts) || []
   ),
-  ...processContributions(contributions == null ? void 0 : contributions.impacts, impactAssessment.impacts || [], (impactAssessment == null ? void 0 : impactAssessment.endpoints) || [])
+  ...processContributions2(contributions == null ? void 0 : contributions.impacts, impactAssessment.impacts || [], (impactAssessment == null ? void 0 : impactAssessment.endpoints) || [])
 ].filter(Boolean);
 var groupLogsById = (logs) => Object.values(
   logs.reduce(
@@ -785,6 +2152,42 @@ var breakdownScale = (values) => {
   };
 };
 
+// src/charts/line.ts
+var defaultLineSettings = Object.freeze({
+  type: "line",
+  options: {
+    scales: {
+      x: {
+        type: "time",
+        time: {
+          unit: "day"
+        },
+        ticks: {
+          font: defaultTicksFont
+        }
+      }
+    }
+  }
+});
+var registerChart = (items = []) => () => {
+  chart_js.Chart.register(
+    chart_js.BarController,
+    chart_js.LineController,
+    chart_js.CategoryScale,
+    chart_js.LinearScale,
+    chart_js.PointElement,
+    chart_js.BarElement,
+    chart_js.LineElement,
+    chart_js.Title,
+    chart_js.Tooltip,
+    chart_js.Legend,
+    chart_js.TimeScale,
+    annotationPlugin__default.default,
+    ...items
+  );
+};
+
+exports.ChartNodeType = ChartNodeType;
 exports.ColorPalette = ColorPalette;
 exports.afterBarDrawPlugin = afterBarDrawPlugin;
 exports.axisHoverPlugin = axisHoverPlugin;
@@ -801,33 +2204,79 @@ exports.chartBreakdownLabel = chartBreakdownLabel;
 exports.chartLabel = chartLabel;
 exports.chartLabelMaxLength = chartLabelMaxLength;
 exports.colorToRgba = colorToRgba;
+exports.contributionBarHeight = contributionBarHeight;
+exports.contributionChartConfig = contributionChartConfig;
+exports.contributionChartHeight = contributionChartHeight;
+exports.contributionCsv = contributionCsv;
+exports.contributionData = contributionData;
+exports.contributionHoverHeight = contributionHoverHeight;
+exports.contributionItemColor = contributionItemColor;
+exports.convertToSvg = convertToSvg;
+exports.d3ellipse = d3ellipse;
+exports.d3wrap = d3wrap;
+exports.dataAtIndex = dataAtIndex;
+exports.datasetCenter = datasetCenter;
 exports.defaultBarDatasets = defaultBarDatasets;
 exports.defaultBarSettings = defaultBarSettings;
+exports.defaultChartSettings = defaultChartSettings;
+exports.defaultContributionSettings = defaultContributionSettings;
+exports.defaultDistributionSettings = defaultDistributionSettings;
 exports.defaultHorizontalBarConfig = defaultHorizontalBarConfig;
 exports.defaultHorizontalTooltip = defaultHorizontalTooltip;
+exports.defaultIndicatorsModelId = defaultIndicatorsModelId;
+exports.defaultIndicatorsModelName = defaultIndicatorsModelName;
+exports.defaultLineSettings = defaultLineSettings;
+exports.defaultModelId = defaultModelId;
 exports.defaultTicksFont = defaultTicksFont;
+exports.distributionChart = distributionChart;
+exports.downloadFile = downloadFile;
+exports.downloadPng = downloadPng;
+exports.downloadSvg = downloadSvg;
+exports.drawHierarchyChart = drawHierarchyChart;
 exports.emissionCategories = emissionCategories;
 exports.emissionCategoriesOf = emissionCategoriesOf;
 exports.emissionCategoryValue = emissionCategoryValue;
 exports.escape = escape;
+exports.exportAsSVG = exportAsSVG;
+exports.formatPrecision = formatPrecision;
 exports.getColor = getColor;
+exports.getUnitsAndLabel = getUnitsAndLabel;
 exports.groupDataByCategory = groupDataByCategory;
+exports.groupIndicators = groupIndicators;
 exports.groupLogsById = groupLogsById;
 exports.hasNegativeContributions = hasNegativeContributions;
+exports.hasNegativeValues = hasNegativeValues;
 exports.hexToRgba = hexToRgba;
+exports.hierarchyChildren = hierarchyChildren;
+exports.hierarchyContributions = hierarchyContributions;
+exports.hierarchyCsv = hierarchyCsv;
+exports.hierarchyData = hierarchyData;
+exports.hierarchyLegend = hierarchyLegend;
+exports.hierarchyModels = hierarchyModels;
+exports.hierarchyTermTypes = hierarchyTermTypes;
+exports.hierarchyWarnings = hierarchyWarnings;
 exports.horizontalBarHeight = horizontalBarHeight;
 exports.increaseScaleLimits = increaseScaleLimits;
 exports.indicatorLogs = indicatorLogs;
+exports.isParametric = isParametric;
+exports.legend = legend;
+exports.linkIndicators = linkIndicators;
 exports.listColor = listColor;
 exports.listColorContinuous = listColorContinuous;
 exports.listColorWithAlpha = listColorWithAlpha;
 exports.logToCsv = logToCsv;
 exports.logsTotalValue = logsTotalValue;
 exports.lollipopChartPlugin = lollipopChartPlugin;
+exports.missingTermIds = missingTermIds;
 exports.namedContributors = namedContributors;
+exports.nodeBorderColours = nodeBorderColours;
+exports.nodeColours = nodeColours;
+exports.nonLCAIndicatorsId = nonLCAIndicatorsId;
 exports.nonZeroContributors = nonZeroContributors;
 exports.parseColor = parseColor;
 exports.parseContributions = parseContributions;
+exports.registerChart = registerChart;
+exports.sumIndicators = sumIndicators;
 exports.sumValues = sumValues;
 exports.toLine = toLine;
 exports.valueRatio = valueRatio;