@unpunnyfuns/d3-blockmap 0.0.0-stage → 0.1.0

package/dist/chunk-WIDC3EN2.js

@@ -0,0 +1,987 @@
+// src/axis.ts
+import { tickStep } from "d3-array";
+
+// src/constants.ts
+var BITS_PER_BYTE = 8;
+var BYTE_SHIFT = 3;
+var BYTE_MASK = 7;
+var BYTES_PER_PIXEL = 4;
+var OPAQUE_ALPHA = 255;
+var COLOR_TABLE_SIZE = 256;
+var PERCENT = 100;
+var PERCENT_FRACTION_DIGITS = 1;
+var TOOLTIP_OFFSET_PX = 8;
+var CANVAS_ROWS = 1;
+var CSS_VAR_MISSING = "--blockmap-missing";
+var CSS_VAR_PARTIAL_LOW = "--blockmap-partial-low";
+var CSS_VAR_PARTIAL_HIGH = "--blockmap-partial-high";
+var CSS_VAR_PARTIAL = "--blockmap-partial";
+var CSS_VAR_COMPLETE = "--blockmap-complete";
+var CSS_VAR_HIGHLIGHT = "--blockmap-highlight";
+var REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+var ZOOM_STEP = 1.25;
+var DRAG_THRESHOLD_PX = 3;
+var BLINK_INTERVAL_MS = 500;
+var MIN_VIEW_LENGTH = 1;
+var DEFAULT_THEME = {
+  missing: "#2b2b2b",
+  partialLow: "#5b3a00",
+  partialHigh: "#e0a500",
+  partial: "#e0a500",
+  complete: "#2ecc71",
+  highlight: "#ff4d4f"
+};
+var THEME_ATTRIBUTES = ["class", "style", "data-theme"];
+var DARK_SCHEME_QUERY = "(prefers-color-scheme: dark)";
+var RANGE_PAIR = 2;
+var FULL_BYTE = 255;
+var MAX_BLOCKS = 4294967295;
+var CSS_VAR_AXIS_COLOR = "--blockmap-axis-color";
+var TICK_SPACING_PX = 80;
+var MIN_TICKS = 2;
+var EDGE_ANCHOR_RATIO = 0.5;
+var DECIMAL_BASE = 10;
+
+// src/dom.ts
+var ensureRelative = (container) => {
+  const position = getComputedStyle(container).position;
+  if (position === "static" || !position) container.style.position = "relative";
+};
+
+// src/view.ts
+var fullView = (totalBlocks) => ({ start: 0, end: totalBlocks });
+var viewLength = (view) => view.end - view.start;
+var sameView = (a, b) => a.start === b.start && a.end === b.end;
+var clampView = (view, totalBlocks) => {
+  let start = Math.round(Math.min(view.start, view.end));
+  let end = Math.round(Math.max(view.start, view.end));
+  if (end - start < MIN_VIEW_LENGTH) end = start + MIN_VIEW_LENGTH;
+  const length = Math.min(end - start, totalBlocks);
+  start = Math.max(0, Math.min(start, totalBlocks - length));
+  return { start, end: start + length };
+};
+var zoomView = (view, anchor, factor, totalBlocks) => {
+  const length = viewLength(view);
+  const scaled = length * factor;
+  const nextLength = Math.max(
+    MIN_VIEW_LENGTH,
+    Math.min(totalBlocks, factor < 1 ? Math.floor(scaled) : Math.ceil(scaled))
+  );
+  const ratio = (anchor - view.start) / length;
+  const start = Math.round(anchor - ratio * nextLength);
+  return clampView({ start, end: start + nextLength }, totalBlocks);
+};
+var panView = (view, deltaBlocks, totalBlocks) => {
+  const length = viewLength(view);
+  const start = Math.round(view.start + deltaBlocks);
+  return clampView({ start, end: start + length }, totalBlocks);
+};
+
+// src/axis.ts
+var AXIS_ATTRIBUTE = "data-blockmap-axis";
+var TICK_ATTRIBUTE = "data-blockmap-tick";
+var FULL = "100%";
+var CENTER = "translateX(-50%)";
+var LEFT_EDGE = "translateX(0)";
+var RIGHT_EDGE = "translateX(-100%)";
+var COMPACT_THRESHOLD = 1e3;
+var MAGNITUDE_STEP = 3;
+var MAX_COMPACT_FRACTION_DIGITS = 3;
+var groupedFormat = new Intl.NumberFormat("en-US");
+var compactFormatters = /* @__PURE__ */ new Map();
+var compactFormatterFor = (digits) => {
+  const cached = compactFormatters.get(digits);
+  if (cached) return cached;
+  const formatter = new Intl.NumberFormat("en-US", {
+    notation: "compact",
+    maximumFractionDigits: digits
+  });
+  compactFormatters.set(digits, formatter);
+  return formatter;
+};
+var defaultFormat = (block, step = 1) => {
+  if (block < COMPACT_THRESHOLD) return groupedFormat.format(block);
+  const magnitude = Math.floor(Math.log10(Math.max(Math.abs(block), 1)) / MAGNITUDE_STEP) * MAGNITUDE_STEP;
+  const unit = DECIMAL_BASE ** magnitude;
+  const digits = Math.max(0, Math.ceil(Math.log10(unit / step)));
+  if (digits > MAX_COMPACT_FRACTION_DIGITS) return groupedFormat.format(block);
+  return compactFormatterFor(digits).format(block);
+};
+var createScale = (view, cssWidth) => {
+  const length = viewLength(view);
+  return {
+    domain: [view.start, view.end],
+    range: [0, cssWidth],
+    x: (block) => cssWidth === 0 ? 0 : (block - view.start) / length * cssWidth,
+    block: (x) => cssWidth === 0 ? view.start : view.start + x / cssWidth * length
+  };
+};
+var computeTicks = (view, cssWidth, tickCount) => {
+  if (cssWidth <= 0) return [];
+  const count = tickCount ?? Math.max(MIN_TICKS, Math.floor(cssWidth / TICK_SPACING_PX));
+  const scale = createScale(view, cssWidth);
+  const rawStep = tickStep(view.start, view.end, count);
+  const step = Math.max(1, rawStep);
+  const first = Math.ceil(view.start / step) * step;
+  const result = [];
+  for (let value = first; value <= view.end; value += step) {
+    result.push({ block: value, x: scale.x(value), step });
+  }
+  return result;
+};
+var anchorFor = (x, cssWidth) => {
+  const edge = TICK_SPACING_PX * EDGE_ANCHOR_RATIO;
+  const nearLeft = x < edge;
+  const nearRight = cssWidth - x < edge;
+  if (nearLeft && nearRight) return x < cssWidth - x ? LEFT_EDGE : RIGHT_EDGE;
+  if (nearLeft) return LEFT_EDGE;
+  if (nearRight) return RIGHT_EDGE;
+  return CENTER;
+};
+var createAxis = (container, options) => {
+  const format = options.format ?? defaultFormat;
+  ensureRelative(container);
+  const root = document.createElement("div");
+  root.setAttribute(AXIS_ATTRIBUTE, "");
+  root.setAttribute("aria-hidden", "true");
+  Object.assign(root.style, {
+    position: "absolute",
+    left: "0",
+    right: "0",
+    top: FULL,
+    pointerEvents: "none",
+    userSelect: "none",
+    color: `var(${CSS_VAR_AXIS_COLOR}, currentColor)`
+  });
+  container.append(root);
+  return {
+    update: (view, cssWidth) => {
+      const spans = computeTicks(view, cssWidth, options.tickCount).map((tick) => {
+        const span = document.createElement("span");
+        span.setAttribute(TICK_ATTRIBUTE, "");
+        span.dataset.block = String(tick.block);
+        span.textContent = format(tick.block, tick.step);
+        Object.assign(span.style, {
+          display: "block",
+          position: "absolute",
+          top: "0",
+          left: `${tick.x}px`,
+          transform: anchorFor(tick.x, cssWidth),
+          whiteSpace: "nowrap"
+        });
+        return span;
+      });
+      root.replaceChildren(...spans);
+    },
+    destroy: () => {
+      root.remove();
+    }
+  };
+};
+
+// src/colors.ts
+import { rgb } from "d3-color";
+import { interpolateRgb, piecewise } from "d3-interpolate";
+var THEME_VARS = {
+  missing: CSS_VAR_MISSING,
+  partialLow: CSS_VAR_PARTIAL_LOW,
+  partialHigh: CSS_VAR_PARTIAL_HIGH,
+  partial: CSS_VAR_PARTIAL,
+  complete: CSS_VAR_COMPLETE,
+  highlight: CSS_VAR_HIGHLIGHT
+};
+var LAST_INDEX = COLOR_TABLE_SIZE - 1;
+var FIRST_PARTIAL_INDEX = 1;
+var LAST_PARTIAL_INDEX = LAST_INDEX - 1;
+var parseOr = (value, fallback) => {
+  try {
+    return rgb(value).displayable() ? value : fallback;
+  } catch {
+    return fallback;
+  }
+};
+var writeColor = (table, index, css) => {
+  const color = rgb(css);
+  const offset = index * BYTES_PER_PIXEL;
+  table.set([color.r, color.g, color.b, OPAQUE_ALPHA], offset);
+};
+var readTheme = (el) => {
+  const style = getComputedStyle(el);
+  const read = (key) => style.getPropertyValue(THEME_VARS[key]).trim() || DEFAULT_THEME[key];
+  return {
+    missing: read("missing"),
+    partialLow: read("partialLow"),
+    partialHigh: read("partialHigh"),
+    partial: read("partial"),
+    complete: read("complete"),
+    highlight: read("highlight")
+  };
+};
+var createColorScale = (theme, partial = "coverage") => {
+  const table = new Uint8ClampedArray(COLOR_TABLE_SIZE * BYTES_PER_PIXEL);
+  const missing = parseOr(theme.missing, DEFAULT_THEME.missing);
+  const complete = parseOr(theme.complete, DEFAULT_THEME.complete);
+  const partialScale = partial === "coverage" ? piecewise(interpolateRgb, [
+    missing,
+    parseOr(theme.partial, DEFAULT_THEME.partial),
+    complete
+  ]) : interpolateRgb(
+    parseOr(theme.partialLow, DEFAULT_THEME.partialLow),
+    parseOr(theme.partialHigh, DEFAULT_THEME.partialHigh)
+  );
+  writeColor(table, 0, missing);
+  writeColor(table, LAST_INDEX, complete);
+  for (let i = FIRST_PARTIAL_INDEX; i <= LAST_PARTIAL_INDEX; i += 1) {
+    writeColor(table, i, partialScale(i / LAST_INDEX));
+  }
+  return (fraction) => {
+    let index = Math.round(fraction * LAST_INDEX);
+    if (fraction > 0 && index < FIRST_PARTIAL_INDEX) index = FIRST_PARTIAL_INDEX;
+    if (fraction < 1 && index > LAST_PARTIAL_INDEX) index = LAST_PARTIAL_INDEX;
+    const offset = index * BYTES_PER_PIXEL;
+    return table.subarray(offset, offset + BYTES_PER_PIXEL);
+  };
+};
+var highlightColor = (theme) => {
+  const color = rgb(parseOr(theme.highlight, DEFAULT_THEME.highlight));
+  return Uint8ClampedArray.of(color.r, color.g, color.b, OPAQUE_ALPHA);
+};
+var watchTheme = (onChange) => {
+  const observer = new MutationObserver(onChange);
+  observer.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: [...THEME_ATTRIBUTES]
+  });
+  const media = matchMedia(DARK_SCHEME_QUERY);
+  media.addEventListener("change", onChange);
+  return () => {
+    observer.disconnect();
+    media.removeEventListener("change", onChange);
+  };
+};
+
+// src/interaction.ts
+var PRIMARY_BUTTON = 0;
+var GRABBING = "grabbing";
+var NO_POINTER = -1;
+var attachInteraction = (canvas, deps) => {
+  let drag;
+  const columnsToBlocks = (px, view) => px * deps.getDpr() / deps.getBinCount() * viewLength(view);
+  const onWheel = (event) => {
+    if (!(event.ctrlKey || event.metaKey)) return;
+    if (drag?.active) return;
+    if (deps.getBinCount() === 0) return;
+    event.preventDefault();
+    const view = deps.getView();
+    const anchor = view.start + columnsToBlocks(event.offsetX, view);
+    const factor = event.deltaY > 0 ? ZOOM_STEP : 1 / ZOOM_STEP;
+    deps.setView(zoomView(view, anchor, factor, deps.getTotalBlocks()));
+  };
+  const onPointerDown = (event) => {
+    if (event.button !== PRIMARY_BUTTON) return;
+    drag = {
+      downX: event.offsetX,
+      view: deps.getView(),
+      pointerId: event.pointerId ?? NO_POINTER,
+      active: false
+    };
+  };
+  const onPointerMove = (event) => {
+    if (!drag) return;
+    const dx = event.offsetX - drag.downX;
+    if (!drag.active) {
+      if (Math.abs(dx) < DRAG_THRESHOLD_PX) return;
+      drag.active = true;
+      if (typeof canvas.setPointerCapture === "function" && drag.pointerId !== NO_POINTER) {
+        canvas.setPointerCapture(drag.pointerId);
+      }
+      canvas.style.cursor = GRABBING;
+      deps.onDragStart();
+    }
+    if (deps.getBinCount() === 0) return;
+    deps.setView(panView(drag.view, -columnsToBlocks(dx, drag.view), deps.getTotalBlocks()));
+  };
+  const endDrag = () => {
+    if (!drag) return;
+    if (drag.active) {
+      const hasCapture = drag.pointerId !== NO_POINTER && (canvas.hasPointerCapture?.(drag.pointerId) ?? true);
+      if (typeof canvas.releasePointerCapture === "function" && hasCapture) {
+        canvas.releasePointerCapture(drag.pointerId);
+      }
+      canvas.style.cursor = "";
+      deps.onDragEnd();
+    }
+    drag = void 0;
+  };
+  const onDblClick = () => deps.resetView();
+  canvas.addEventListener("wheel", onWheel, { passive: false });
+  canvas.addEventListener("pointerdown", onPointerDown);
+  canvas.addEventListener("pointermove", onPointerMove);
+  canvas.addEventListener("pointerup", endDrag);
+  canvas.addEventListener("pointercancel", endDrag);
+  canvas.addEventListener("dblclick", onDblClick);
+  return () => {
+    endDrag();
+    canvas.removeEventListener("wheel", onWheel);
+    canvas.removeEventListener("pointerdown", onPointerDown);
+    canvas.removeEventListener("pointermove", onPointerMove);
+    canvas.removeEventListener("pointerup", endDrag);
+    canvas.removeEventListener("pointercancel", endDrag);
+    canvas.removeEventListener("dblclick", onDblClick);
+  };
+};
+
+// src/renderer.ts
+var NO_FRAME = 0;
+var NO_TIMER = 0;
+var COMPLETE = 1;
+var RAF_SCHEDULER = {
+  request: (callback) => requestAnimationFrame(callback),
+  cancel: (handle) => cancelAnimationFrame(handle)
+};
+var WINDOW_TIMER = {
+  set: (callback, ms) => window.setInterval(callback, ms),
+  clear: (id) => window.clearInterval(id)
+};
+var createRenderer = (ctx, source, scheduler = RAF_SCHEDULER, timer = WINDOW_TIMER) => {
+  let image;
+  let scale;
+  let frame = NO_FRAME;
+  let scheduled = false;
+  let allDirty = false;
+  let highlight;
+  let phase = false;
+  let blinkId = NO_TIMER;
+  const dirty = /* @__PURE__ */ new Set();
+  const ensureImage = () => {
+    const { binCount } = source;
+    if (binCount === 0) return void 0;
+    if (!image || image.width !== binCount) {
+      image = ctx.createImageData(binCount, CANVAS_ROWS);
+      allDirty = true;
+    }
+    return image;
+  };
+  const colorFor = (colors, fraction) => highlight && phase && fraction < COMPLETE ? highlight : colors(fraction);
+  const writeColumn = (target, column, color) => {
+    target.data.set(color, column * BYTES_PER_PIXEL);
+  };
+  const paintDiscrete = (target, colors) => {
+    const { view, binCount } = source;
+    const length = viewLength(view);
+    for (let block = 0; block < length; block += 1) {
+      const color = colorFor(colors, source.has(view.start + block) ? COMPLETE : 0);
+      const start = Math.floor(block * binCount / length);
+      const end = Math.floor((block + 1) * binCount / length);
+      for (let column = start; column < end; column += 1) writeColumn(target, column, color);
+    }
+  };
+  const paintBins = (target, colors) => {
+    if (allDirty) {
+      for (let bin = 0; bin < source.binCount; bin += 1)
+        writeColumn(target, bin, colorFor(colors, source.fraction(bin)));
+      return;
+    }
+    for (const bin of dirty) {
+      if (bin >= target.width) continue;
+      writeColumn(target, bin, colorFor(colors, source.fraction(bin)));
+    }
+  };
+  const paint = () => {
+    scheduled = false;
+    frame = NO_FRAME;
+    const target = ensureImage();
+    if (!target || !scale) {
+      dirty.clear();
+      allDirty = false;
+      return;
+    }
+    if (viewLength(source.view) < source.binCount) paintDiscrete(target, scale);
+    else paintBins(target, scale);
+    ctx.putImageData(target, 0, 0);
+    dirty.clear();
+    allDirty = false;
+  };
+  const schedule = () => {
+    if (scheduled) return;
+    scheduled = true;
+    frame = scheduler.request(paint);
+  };
+  const markAllDirty = () => {
+    allDirty = true;
+    schedule();
+  };
+  const stopBlink = () => {
+    if (blinkId !== NO_TIMER) timer.clear(blinkId);
+    blinkId = NO_TIMER;
+  };
+  return {
+    setColors: (next) => {
+      scale = next;
+      markAllDirty();
+    },
+    setHighlight: (on, color, blink) => {
+      if (!on && highlight === void 0) return;
+      stopBlink();
+      highlight = on ? color : void 0;
+      phase = on;
+      if (on && blink) {
+        blinkId = timer.set(() => {
+          phase = !phase;
+          markAllDirty();
+        }, BLINK_INTERVAL_MS);
+      }
+      markAllDirty();
+    },
+    setHighlightColor: (color) => {
+      if (highlight === void 0) return;
+      highlight = color;
+      markAllDirty();
+    },
+    markDirty: (bins) => {
+      for (let i = 0; i < bins.length; i += 1) dirty.add(bins[i]);
+      if (bins.length > 0) schedule();
+    },
+    markAllDirty,
+    destroy: () => {
+      stopBlink();
+      if (scheduled) scheduler.cancel(frame);
+      scheduled = false;
+      frame = NO_FRAME;
+      dirty.clear();
+    }
+  };
+};
+
+// src/bitset.ts
+var maskRange = (from, to) => (1 << to) - 1 & ~((1 << from) - 1);
+var POPCOUNT = new Uint8Array(1 << BITS_PER_BYTE);
+for (let i = 1; i < POPCOUNT.length; i += 1) {
+  POPCOUNT[i] = POPCOUNT[i >> 1] + (i & 1);
+}
+var createBitset = (size) => {
+  const bytes = new Uint8Array(Math.ceil(size / BITS_PER_BYTE));
+  let count = 0;
+  return {
+    has: (index) => (bytes[index >>> BYTE_SHIFT] & 1 << (index & BYTE_MASK)) !== 0,
+    set: (index) => {
+      const byte = index >>> BYTE_SHIFT;
+      const mask = 1 << (index & BYTE_MASK);
+      if ((bytes[byte] & mask) !== 0) return false;
+      bytes[byte] |= mask;
+      count += 1;
+      return true;
+    },
+    fill: (start, end) => {
+      if (end <= start) return;
+      const firstByte = start >>> BYTE_SHIFT;
+      const lastByte = end - 1 >>> BYTE_SHIFT;
+      const fromBit = start & BYTE_MASK;
+      const toBit = (end - 1 & BYTE_MASK) + 1;
+      if (firstByte === lastByte) {
+        bytes[firstByte] |= maskRange(fromBit, toBit);
+        return;
+      }
+      bytes[firstByte] |= maskRange(fromBit, BITS_PER_BYTE);
+      bytes.fill(FULL_BYTE, firstByte + 1, lastByte);
+      bytes[lastByte] |= maskRange(0, toBit);
+    },
+    clearRange: (start, end) => {
+      if (end <= start) return;
+      const firstByte = start >>> BYTE_SHIFT;
+      const lastByte = end - 1 >>> BYTE_SHIFT;
+      const fromBit = start & BYTE_MASK;
+      const toBit = (end - 1 & BYTE_MASK) + 1;
+      if (firstByte === lastByte) {
+        bytes[firstByte] &= ~maskRange(fromBit, toBit);
+        return;
+      }
+      bytes[firstByte] &= ~maskRange(fromBit, BITS_PER_BYTE);
+      bytes.fill(0, firstByte + 1, lastByte);
+      bytes[lastByte] &= ~maskRange(0, toBit);
+    },
+    countRange: (start, end) => {
+      if (end <= start) return 0;
+      const firstByte = start >>> BYTE_SHIFT;
+      const lastByte = end - 1 >>> BYTE_SHIFT;
+      const fromBit = start & BYTE_MASK;
+      const toBit = (end - 1 & BYTE_MASK) + 1;
+      if (firstByte === lastByte) {
+        return POPCOUNT[bytes[firstByte] & maskRange(fromBit, toBit)];
+      }
+      let total = POPCOUNT[bytes[firstByte] & maskRange(fromBit, BITS_PER_BYTE)];
+      for (let b = firstByte + 1; b < lastByte; b += 1) total += POPCOUNT[bytes[b]];
+      total += POPCOUNT[bytes[lastByte] & maskRange(0, toBit)];
+      return total;
+    },
+    clear: () => {
+      bytes.fill(0);
+      count = 0;
+    },
+    setCount: (next) => {
+      count = next;
+    },
+    get count() {
+      return count;
+    }
+  };
+};
+
+// src/bins.ts
+var clipToView = (rawStart, rawEnd, viewStart, viewEnd) => ({
+  start: Math.max(rawStart, viewStart),
+  end: Math.min(rawEnd, viewEnd)
+});
+var createBins = (view, binCount) => {
+  const { start: viewStart, end: viewEnd } = view;
+  const length = viewEnd - viewStart;
+  const counts = new Uint32Array(binCount);
+  const binOf = (index) => Math.floor((index - viewStart) * binCount / length);
+  const rangeOf = (bin) => ({
+    start: viewStart + Math.ceil(bin * length / binCount),
+    end: viewStart + Math.ceil((bin + 1) * length / binCount)
+  });
+  const sizeOf = (bin) => {
+    const { start, end } = rangeOf(bin);
+    return end - start;
+  };
+  return {
+    view,
+    binCount,
+    counts,
+    binOf,
+    rangeOf,
+    sizeOf,
+    rebuild: (countInRange) => {
+      counts.fill(0);
+      if (binCount === 0) return;
+      for (let bin = 0; bin < binCount; bin += 1) {
+        const { start, end } = rangeOf(bin);
+        counts[bin] = countInRange(start, end);
+      }
+    },
+    addRange: (rawStart, rawEnd) => {
+      const { start, end } = clipToView(rawStart, rawEnd, viewStart, viewEnd);
+      if (binCount === 0 || end <= start) return;
+      const first = binOf(start);
+      const last = binOf(end - 1);
+      if (first === last) {
+        counts[first] += end - start;
+        return;
+      }
+      counts[first] += rangeOf(first).end - start;
+      for (let bin = first + 1; bin < last; bin += 1) counts[bin] += sizeOf(bin);
+      counts[last] += end - rangeOf(last).start;
+    },
+    binsTouching: (rawStart, rawEnd) => {
+      const { start, end } = clipToView(rawStart, rawEnd, viewStart, viewEnd);
+      if (binCount === 0 || end <= start) return [];
+      const first = binOf(start);
+      const last = binOf(end - 1);
+      const touched = [];
+      for (let bin = first; bin <= last; bin += 1) touched.push(bin);
+      return touched;
+    },
+    recountBins: (bins, countInRange) => {
+      for (const bin of bins) {
+        const range = rangeOf(bin);
+        counts[bin] = countInRange(range.start, range.end);
+      }
+    }
+  };
+};
+
+// src/ranges.ts
+var isFlatPairs = (input) => ArrayBuffer.isView(input) || typeof input[0] === "number";
+var readPairs = (input) => {
+  const pairs = [];
+  if (isFlatPairs(input)) {
+    const pairCount = Math.floor(input.length / RANGE_PAIR);
+    for (let i = 0; i < pairCount; i += 1) {
+      pairs.push([input[i * RANGE_PAIR], input[i * RANGE_PAIR + 1]]);
+    }
+    return pairs;
+  }
+  for (let i = 0; i < input.length; i += 1) {
+    const tuple = input[i];
+    pairs.push([tuple[0], tuple[1]]);
+  }
+  return pairs;
+};
+var normalizeRanges = (input, totalBlocks) => {
+  const clamped = [];
+  for (const [rawStart, rawEnd] of readPairs(input)) {
+    if (!Number.isInteger(rawStart) || !Number.isInteger(rawEnd)) continue;
+    const start = Math.max(0, rawStart);
+    const end = Math.min(totalBlocks, rawEnd);
+    if (end > start) clamped.push([start, end]);
+  }
+  clamped.sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const [start, end] of clamped) {
+    const lastIndex = merged.length - 1;
+    if (merged.length > 0 && start <= merged[lastIndex]) {
+      merged[lastIndex] = Math.max(merged[lastIndex], end);
+    } else {
+      merged.push(start, end);
+    }
+  }
+  return Uint32Array.from(merged);
+};
+var rangesLength = (flat) => {
+  let total = 0;
+  for (let i = 0; i < flat.length; i += RANGE_PAIR) total += flat[i + 1] - flat[i];
+  return total;
+};
+
+// src/state.ts
+var EMPTY_DIRTY = new Uint32Array(0);
+var isValidIndex = (index, totalBlocks) => Number.isInteger(index) && index >= 0 && index < totalBlocks;
+var createBlockState = (totalBlocks) => {
+  if (!Number.isInteger(totalBlocks) || totalBlocks < 1) {
+    throw new RangeError(`totalBlocks must be a positive integer, got ${totalBlocks}`);
+  }
+  if (totalBlocks > MAX_BLOCKS) {
+    throw new RangeError(
+      `totalBlocks must fit in an unsigned 32-bit integer (<= ${MAX_BLOCKS}), got ${totalBlocks}`
+    );
+  }
+  const bitset = createBitset(totalBlocks);
+  let view = fullView(totalBlocks);
+  let bins = createBins(view, 0);
+  const inView = (index) => index >= view.start && index < view.end;
+  const add = (indices) => {
+    const hasBins = bins.binCount > 0;
+    const dirty = /* @__PURE__ */ new Set();
+    for (let i = 0; i < indices.length; i += 1) {
+      const index = indices[i];
+      if (!isValidIndex(index, totalBlocks) || !bitset.set(index)) continue;
+      if (!hasBins || !inView(index)) continue;
+      const bin = bins.binOf(index);
+      bins.counts[bin] += 1;
+      dirty.add(bin);
+    }
+    return dirty.size === 0 ? EMPTY_DIRTY : Uint32Array.from(dirty).sort();
+  };
+  const applyRanges = (input, complete) => {
+    const flat = normalizeRanges(input, totalBlocks);
+    const dirty = /* @__PURE__ */ new Set();
+    let delta = 0;
+    for (let i = 0; i < flat.length; i += RANGE_PAIR) {
+      const start = flat[i];
+      const end = flat[i + 1];
+      const present = bitset.countRange(start, end);
+      if (complete) {
+        bitset.fill(start, end);
+        delta += end - start - present;
+      } else {
+        bitset.clearRange(start, end);
+        delta -= present;
+      }
+      for (const bin of bins.binsTouching(start, end)) dirty.add(bin);
+    }
+    bins.recountBins(dirty, bitset.countRange);
+    bitset.setCount(bitset.count + delta);
+    return dirty.size === 0 ? EMPTY_DIRTY : Uint32Array.from(dirty).sort();
+  };
+  return {
+    totalBlocks,
+    get binCount() {
+      return bins.binCount;
+    },
+    get view() {
+      return view;
+    },
+    resize: (binCount) => {
+      bins = createBins(view, binCount);
+      bins.rebuild(bitset.countRange);
+    },
+    setView: (next) => {
+      if (!Number.isFinite(next.start) || !Number.isFinite(next.end)) return false;
+      const clamped = clampView(next, totalBlocks);
+      if (sameView(clamped, view)) return false;
+      view = clamped;
+      bins = createBins(view, bins.binCount);
+      bins.rebuild(bitset.countRange);
+      return true;
+    },
+    getView: () => ({ ...view }),
+    add,
+    replace: (indices) => {
+      bitset.clear();
+      bins.counts.fill(0);
+      add(indices);
+    },
+    replaceRanges: (input) => {
+      const flat = normalizeRanges(input, totalBlocks);
+      bitset.clear();
+      bins.counts.fill(0);
+      for (let i = 0; i < flat.length; i += RANGE_PAIR) {
+        bitset.fill(flat[i], flat[i + 1]);
+        bins.addRange(flat[i], flat[i + 1]);
+      }
+      bitset.setCount(rangesLength(flat));
+    },
+    addRanges: (input) => applyRanges(input, true),
+    removeRanges: (input) => applyRanges(input, false),
+    has: bitset.has,
+    fraction: (bin) => {
+      const size = bins.sizeOf(bin);
+      return size === 0 ? 0 : bins.counts[bin] / size;
+    },
+    countOf: (bin) => bins.counts[bin],
+    sizeOf: (bin) => bins.sizeOf(bin),
+    rangeOf: (bin) => bins.rangeOf(bin),
+    progress: () => ({ completed: bitset.count, total: totalBlocks })
+  };
+};
+
+// src/tooltip.ts
+var LOCALE = "en-US";
+var TOOLTIP_ATTRIBUTE = "data-blockmap-tooltip";
+var SEPARATOR = " \xB7 ";
+var EN_DASH = "\u2013";
+var countFormat = new Intl.NumberFormat(LOCALE);
+var MIN_PARTIAL_STEP = 1 / DECIMAL_BASE ** PERCENT_FRACTION_DIGITS;
+var MAX_PARTIAL = (PERCENT - MIN_PARTIAL_STEP).toFixed(PERCENT_FRACTION_DIGITS);
+var MIN_PARTIAL = MIN_PARTIAL_STEP.toFixed(PERCENT_FRACTION_DIGITS);
+var MAX_FIXED = PERCENT.toFixed(PERCENT_FRACTION_DIGITS);
+var MIN_FIXED = 0 .toFixed(PERCENT_FRACTION_DIGITS);
+var formatPercent = (count, size) => {
+  if (count === 0) return "0%";
+  if (count === size) return "100%";
+  const value = count / size * PERCENT;
+  const text = value.toFixed(PERCENT_FRACTION_DIGITS);
+  if (text === MAX_FIXED) {
+    return `>${MAX_PARTIAL}%`;
+  }
+  if (text === MIN_FIXED) {
+    return `<${MIN_PARTIAL}%`;
+  }
+  return `${text}%`;
+};
+var formatBinTooltip = (range, count) => {
+  const size = range.end - range.start;
+  const label = size === 1 ? `Block ${countFormat.format(range.start)}` : `Blocks ${countFormat.format(range.start)}${EN_DASH}${countFormat.format(range.end - 1)}`;
+  return `${label}${SEPARATOR}${countFormat.format(count)} / ${countFormat.format(size)} (${formatPercent(count, size)})`;
+};
+var formatBlockTooltip = (index, complete) => `Block ${countFormat.format(index)}${SEPARATOR}${complete ? "complete" : "missing"}`;
+var createTooltip = (container) => {
+  const el = document.createElement("div");
+  el.setAttribute(TOOLTIP_ATTRIBUTE, "");
+  Object.assign(el.style, {
+    position: "absolute",
+    top: "0",
+    left: "0",
+    display: "none",
+    pointerEvents: "none",
+    whiteSpace: "nowrap",
+    transform: "translateY(-100%)"
+  });
+  ensureRelative(container);
+  container.append(el);
+  return {
+    show: (x, text) => {
+      el.textContent = text;
+      el.style.left = `${x + TOOLTIP_OFFSET_PX}px`;
+      el.style.display = "block";
+    },
+    hide: () => {
+      el.style.display = "none";
+    },
+    destroy: () => {
+      el.remove();
+    }
+  };
+};
+
+// src/blockMap.ts
+var FULL2 = "100%";
+var CONTEXT_ID = "2d";
+var NO_FRAME2 = 0;
+var dprQuery = (dpr) => `(resolution: ${dpr}dppx)`;
+var discreteBlock = (column, length, binCount, start) => start + Math.ceil((column + 1) * length / binCount) - 1;
+var createBlockMap = (container, options) => {
+  const state = createBlockState(options.totalBlocks);
+  if (options.view) state.setView(options.view);
+  const canvas = document.createElement("canvas");
+  Object.assign(canvas.style, {
+    display: "block",
+    width: FULL2,
+    height: FULL2,
+    touchAction: "none"
+  });
+  canvas.height = CANVAS_ROWS;
+  container.append(canvas);
+  const ctx = canvas.getContext(CONTEXT_ID);
+  if (!ctx) {
+    canvas.remove();
+    throw new Error(`Could not acquire a ${CONTEXT_ID} canvas context`);
+  }
+  const renderer = createRenderer(ctx, state);
+  const tooltip = createTooltip(container);
+  const axisOptions = options.axis === true ? {} : options.axis === false || options.axis === void 0 ? void 0 : options.axis;
+  const axis = axisOptions ? createAxis(container, axisOptions) : void 0;
+  let destroyed = false;
+  let cssWidth = 0;
+  let dpr = devicePixelRatio;
+  let dprMedia;
+  let theme = readTheme(container);
+  let highlightOn = false;
+  let dragging = false;
+  const blinkAllowed = () => !matchMedia(REDUCED_MOTION_QUERY).matches;
+  const applyHighlight = () => {
+    renderer.setHighlight(highlightOn, highlightColor(theme), blinkAllowed());
+  };
+  const applyTheme = () => {
+    theme = readTheme(container);
+    renderer.setColors(createColorScale(theme, options.partial));
+    if (highlightOn) renderer.setHighlightColor(highlightColor(theme));
+  };
+  let pendingView;
+  let viewFrame = NO_FRAME2;
+  const getView = () => ({ ...pendingView ?? state.view });
+  const commitView = () => {
+    viewFrame = NO_FRAME2;
+    const next = pendingView;
+    pendingView = void 0;
+    if (!next || !state.setView(next)) return;
+    renderer.markAllDirty();
+    axis?.update(state.view, cssWidth);
+    options.onViewChange?.(state.getView());
+  };
+  const setView = (view) => {
+    if (!Number.isFinite(view.start) || !Number.isFinite(view.end)) return;
+    const clamped = clampView(view, state.totalBlocks);
+    if (sameView(clamped, pendingView ?? state.view)) return;
+    const hasPendingFrame = pendingView !== void 0;
+    pendingView = clamped;
+    if (!hasPendingFrame) viewFrame = requestAnimationFrame(commitView);
+  };
+  const resetView = () => setView(fullView(state.totalBlocks));
+  const layout = () => {
+    const binCount = Math.round(cssWidth * dpr);
+    if (binCount === state.binCount) return;
+    canvas.width = binCount;
+    state.resize(binCount);
+    renderer.markAllDirty();
+    axis?.update(state.view, cssWidth);
+  };
+  const onDprChange = () => {
+    dpr = devicePixelRatio;
+    layout();
+    watchDpr();
+  };
+  const watchDpr = () => {
+    dprMedia?.removeEventListener("change", onDprChange);
+    dprMedia = matchMedia(dprQuery(dpr));
+    dprMedia.addEventListener("change", onDprChange, { once: true });
+  };
+  const resizeObserver = new ResizeObserver((entries) => {
+    const entry = entries[0];
+    if (!entry) return;
+    cssWidth = entry.contentRect.width;
+    layout();
+  });
+  resizeObserver.observe(container);
+  const onPointerMove = (event) => {
+    if (dragging) return;
+    const { binCount, view } = state;
+    if (binCount === 0) return;
+    const column = Math.min(binCount - 1, Math.max(0, Math.floor(event.offsetX * dpr)));
+    const length = viewLength(view);
+    let text;
+    if (length < binCount) {
+      const block = discreteBlock(column, length, binCount, view.start);
+      text = formatBlockTooltip(block, state.has(block));
+    } else {
+      text = formatBinTooltip(state.rangeOf(column), state.countOf(column));
+    }
+    tooltip.show(event.offsetX, text);
+  };
+  const onPointerLeave = () => tooltip.hide();
+  canvas.addEventListener("pointermove", onPointerMove);
+  canvas.addEventListener("pointerleave", onPointerLeave);
+  const detachInteraction = options.interactive === false ? void 0 : attachInteraction(canvas, {
+    getView,
+    setView,
+    resetView,
+    getBinCount: () => state.binCount,
+    getDpr: () => dpr,
+    getTotalBlocks: () => state.totalBlocks,
+    onDragStart: () => {
+      dragging = true;
+      tooltip.hide();
+    },
+    onDragEnd: () => {
+      dragging = false;
+    }
+  });
+  const unwatchTheme = watchTheme(applyTheme);
+  watchDpr();
+  applyTheme();
+  if (options.initialRanges) state.replaceRanges(options.initialRanges);
+  if (options.initialBlocks) renderer.markDirty(state.add(options.initialBlocks));
+  return {
+    setBlocks: (indices) => {
+      if (destroyed) return;
+      state.replace(indices);
+      renderer.markAllDirty();
+    },
+    setRanges: (ranges) => {
+      if (destroyed) return;
+      state.replaceRanges(ranges);
+      renderer.markAllDirty();
+    },
+    addBlocks: (indices) => {
+      if (destroyed) return;
+      renderer.markDirty(state.add(indices));
+    },
+    addRanges: (ranges) => {
+      if (destroyed) return;
+      renderer.markDirty(state.addRanges(ranges));
+    },
+    removeRanges: (ranges) => {
+      if (destroyed) return;
+      renderer.markDirty(state.removeRanges(ranges));
+    },
+    setView: (view) => {
+      if (destroyed) return;
+      setView(view);
+    },
+    resetView: () => {
+      if (destroyed) return;
+      resetView();
+    },
+    getView,
+    getScale: () => createScale(state.getView(), cssWidth),
+    setHighlight: (on) => {
+      if (destroyed) return;
+      highlightOn = on;
+      applyHighlight();
+    },
+    getProgress: () => destroyed ? { completed: 0, total: state.totalBlocks } : state.progress(),
+    destroy: () => {
+      if (destroyed) return;
+      destroyed = true;
+      if (viewFrame !== NO_FRAME2) cancelAnimationFrame(viewFrame);
+      viewFrame = NO_FRAME2;
+      pendingView = void 0;
+      resizeObserver.disconnect();
+      unwatchTheme();
+      dprMedia?.removeEventListener("change", onDprChange);
+      canvas.removeEventListener("pointermove", onPointerMove);
+      canvas.removeEventListener("pointerleave", onPointerLeave);
+      detachInteraction?.();
+      renderer.destroy();
+      tooltip.destroy();
+      axis?.destroy();
+      canvas.remove();
+    }
+  };
+};
+
+export {
+  createBlockMap
+};
+//# sourceMappingURL=chunk-WIDC3EN2.js.map