sk-chart-duo 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1310 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChartBase: () => ChartBase,
+  FoldBarChart: () => FoldBarChart,
+  VERSION: () => VERSION,
+  createBandScale: () => createBandScale,
+  createLinearScale: () => createLinearScale,
+  createPowerScale: () => createPowerScale,
+  defaultTooltipFormatter: () => defaultTooltipFormatter,
+  defaultValueFormat: () => defaultValueFormat,
+  getTheme: () => getTheme,
+  isThemePack: () => isThemePack,
+  niceScale: () => niceScale,
+  registerTheme: () => registerTheme
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/exporter.ts
+function svgToMarkup(svg) {
+  const clone = svg.cloneNode(true);
+  const size = viewBoxSize(svg);
+  if (size) {
+    clone.setAttribute("width", String(size.width));
+    clone.setAttribute("height", String(size.height));
+  }
+  clone.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  return new XMLSerializer().serializeToString(clone);
+}
+function svgToDataUrl(svg) {
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svgToMarkup(svg))}`;
+}
+async function svgToPngDataUrl(svg, scale = 2, background) {
+  const size = viewBoxSize(svg) ?? { width: svg.clientWidth, height: svg.clientHeight };
+  if (!size.width || !size.height) throw new Error("sk-chart: cannot measure SVG for raster export");
+  const canvas = document.createElement("canvas");
+  canvas.width = Math.round(size.width * scale);
+  canvas.height = Math.round(size.height * scale);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("sk-chart: canvas 2d context unavailable");
+  const url = URL.createObjectURL(new Blob([svgToMarkup(svg)], { type: "image/svg+xml;charset=utf-8" }));
+  try {
+    const image = await loadImage(url);
+    if (background) {
+      ctx.fillStyle = background;
+      ctx.fillRect(0, 0, canvas.width, canvas.height);
+    }
+    ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+    return canvas.toDataURL("image/png");
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+function viewBoxSize(svg) {
+  const [, , w, h] = (svg.getAttribute("viewBox") ?? "").split(/[\s,]+/).map(Number);
+  return Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0 ? { width: w, height: h } : null;
+}
+function loadImage(url) {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.onload = () => resolve(image);
+    image.onerror = () => reject(new Error("sk-chart: failed to rasterize SVG"));
+    image.src = url;
+  });
+}
+function triggerDownload(href, filename) {
+  const anchor = document.createElement("a");
+  anchor.href = href;
+  anchor.download = filename;
+  document.body.appendChild(anchor);
+  anchor.click();
+  anchor.remove();
+}
+
+// src/core/chart-base.ts
+var ChartBase = class {
+  constructor(container, config) {
+    this.svg = null;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.destroyed = false;
+    const element = typeof container === "string" ? document.querySelector(container) : container;
+    if (!element) {
+      throw new Error(`sk-chart: container "${String(container)}" not found`);
+    }
+    this.container = element;
+    this.config = config;
+  }
+  get isDestroyed() {
+    return this.destroyed;
+  }
+  on(event, handler) {
+    if (this.destroyed) return this;
+    const set = this.handlers.get(event) ?? /* @__PURE__ */ new Set();
+    this.handlers.set(event, set);
+    set.add(handler);
+    return this;
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+    return this;
+  }
+  emit(event, payload) {
+    this.handlers.get(event)?.forEach((handler) => handler(payload));
+  }
+  /** Merges the partial config and rebuilds the chart. */
+  update(config) {
+    if (this.destroyed) return;
+    this.config = { ...this.config, ...config };
+    this.renderChart();
+  }
+  /** Changes the viewBox design space and rebuilds (userSpaceOnUse coordinates depend on it). */
+  resize(width, height) {
+    this.update({ width, height });
+  }
+  /** Standalone SVG markup (embedded style + defs included), renderable as-is. */
+  toSVGString() {
+    return svgToMarkup(this.requireSvg());
+  }
+  /** Data URL of the current chart; PNG is rasterized through canvas at `scale` (default 2x). */
+  async getDataURL(options = {}) {
+    const { type = "png", scale = 2, background } = options;
+    const svg = this.requireSvg();
+    return type === "svg" ? svgToDataUrl(svg) : svgToPngDataUrl(svg, scale, background);
+  }
+  /** Triggers a browser download of the chart, PNG at 2x by default. */
+  async download(options = {}) {
+    const { filename = "sk-chart", type = "png", scale, background } = options;
+    const url = await this.getDataURL({ type, scale, background });
+    triggerDownload(url, `${filename}.${type}`);
+  }
+  requireSvg() {
+    if (this.destroyed || !this.svg) throw new Error("sk-chart: chart is not rendered");
+    return this.svg;
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.onDestroy();
+    this.svg?.remove();
+    this.svg = null;
+    this.handlers.clear();
+  }
+  /** Subclass teardown hook, called before the SVG is removed. */
+  onDestroy() {
+  }
+};
+
+// src/core/svg-renderer.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+function createSvgElement(tag, attrs = {}) {
+  const node = document.createElementNS(SVG_NS, tag);
+  for (const [key, value] of Object.entries(attrs)) {
+    node.setAttribute(key, String(value));
+  }
+  return node;
+}
+function addStops(gradient, stops) {
+  for (const [offset, color] of stops) {
+    gradient.appendChild(createSvgElement("stop", { offset, "stop-color": color }));
+  }
+  return gradient;
+}
+var uidCounter = 0;
+function createUid(prefix = "skc") {
+  uidCounter += 1;
+  return `${prefix}${uidCounter.toString(36)}${Math.random().toString(36).slice(2, 7)}`;
+}
+function scopedId(uid, name) {
+  return `${uid}-${name}`;
+}
+function urlRef(uid, name) {
+  return `url(#${scopedId(uid, name)})`;
+}
+
+// src/charts/fold-bar/geometry.ts
+function computeLayout(input) {
+  const left = input.padding.left;
+  const right = input.width - input.padding.right;
+  const top = input.padding.top;
+  const bottom = input.height - input.padding.bottom;
+  const count = input.values.length;
+  const colWidth = count > 0 ? (right - left) / count : 0;
+  const barWidth = colWidth - input.foldRun - input.barGap;
+  const stairBase = bottom - input.stairBottomOffset;
+  const stairTop = top + input.stairTopOffset;
+  const maxValue = count > 0 ? Math.max(...input.values) : 0;
+  const domainMax = Math.max(input.domainMax, maxValue);
+  const span = stairBase - stairTop;
+  const barTopOf = (value) => {
+    if (domainMax <= 0) return stairBase;
+    const t = Math.pow(Math.max(0, value / domainMax), input.exponent);
+    return stairBase - t * span;
+  };
+  return {
+    plot: { left, right, top, bottom, width: right - left, height: bottom - top },
+    count,
+    colWidth,
+    barWidth,
+    stairBase,
+    stairTop,
+    maxValue,
+    domainMax,
+    barTopOf
+  };
+}
+function barGeometry(layout, index, value) {
+  const colStart = layout.plot.left + index * layout.colWidth;
+  const x = colStart + 1;
+  const y = layout.barTopOf(value);
+  return {
+    colStart,
+    x,
+    y,
+    width: layout.barWidth,
+    height: layout.plot.bottom - y,
+    centerX: x + layout.barWidth / 2
+  };
+}
+function flapGeometry(layout, index, values) {
+  if (index >= values.length - 1) return null;
+  const x0 = layout.plot.left + index * layout.colWidth + 1 + layout.barWidth;
+  const x1 = layout.plot.left + (index + 1) * layout.colWidth + 2;
+  const y0 = layout.barTopOf(values[index]);
+  const y1 = layout.barTopOf(values[index + 1]);
+  const bottom = layout.plot.bottom;
+  return {
+    points: `${x0},${y0} ${x1},${y1} ${x1},${bottom} ${x0},${bottom}`,
+    crease: { x1: x0, y1: y0, x2: x1, y2: y1 },
+    gradientY: [y0, bottom]
+  };
+}
+function pillGeometry(centerX, barTop, pill) {
+  return {
+    x: centerX - pill.width / 2,
+    y: barTop + pill.offsetY,
+    width: pill.width,
+    height: pill.height,
+    rx: pill.rx,
+    shadowX: centerX - pill.shadow.width / 2,
+    shadowY: barTop + pill.shadow.offsetY,
+    shadowWidth: pill.shadow.width,
+    shadowHeight: pill.shadow.height,
+    shadowRx: pill.shadow.rx
+  };
+}
+function gridLineXs(layout) {
+  return Array.from({ length: layout.count + 1 }, (_, i) => layout.plot.left + i * layout.colWidth);
+}
+function tooltipPlacement(layout, bar, tipWidth, options) {
+  const rawX = bar.x + bar.width * options.anchorRatio;
+  const y = Math.max(bar.y + options.offsetY, options.minY);
+  const { left, right } = layout.plot;
+  const x = Math.min(Math.max(rawX, left), Math.max(left, right - tipWidth));
+  return { x, y };
+}
+function hitRect(layout, index) {
+  return {
+    x: layout.plot.left + index * layout.colWidth,
+    y: layout.plot.top,
+    width: layout.colWidth,
+    height: layout.plot.height
+  };
+}
+function washRect(bar, washTop) {
+  return {
+    x: bar.x,
+    y: washTop,
+    width: bar.width,
+    height: Math.max(0, bar.y - washTop)
+  };
+}
+
+// src/theme/default-theme.ts
+var BAR_GRADIENT_ACTIVE = [
+  [0, "#2A2FC8"],
+  [0.07, "#2A55E2"],
+  [0.22, "#2C62EC"],
+  [0.42, "#3184F7"],
+  [0.62, "#77ABF5"],
+  [0.82, "#C5DAF5"],
+  [1, "#EAF1FA"]
+];
+var BAR_GRADIENT_NORMAL = [
+  [0, "#2B3AD6"],
+  [0.07, "#2C60EC"],
+  [0.22, "#2F76F2"],
+  [0.42, "#4C93F8"],
+  [0.62, "#87B5F6"],
+  [0.82, "#CDDDF5"],
+  [1, "#EBF2FA"]
+];
+var DEFAULT_STYLE = {
+  stripePattern: {
+    enabled: true,
+    size: 7.1,
+    lineWidth: 2.1,
+    lineColor: "#fff",
+    lineOpacity: 0.93,
+    rotation: 45
+  },
+  barGradientActive: BAR_GRADIENT_ACTIVE,
+  barGradientNormal: BAR_GRADIENT_NORMAL,
+  foldGradient: [
+    [0, "#8FB2F8"],
+    [0.14, "#A6C2FA"],
+    [0.38, "#C6DAFA"],
+    [0.68, "#E6EDFB"],
+    [1, "#F4F7FC"]
+  ],
+  creaseGradient: [
+    [0, "rgba(255,255,255,0)"],
+    [0.18, "rgba(255,255,255,.62)"],
+    [0.55, "rgba(255,255,255,.18)"],
+    [1, "rgba(255,255,255,0)"]
+  ],
+  washTop: 115,
+  washGradient: [
+    [0, "rgba(222,240,254,0)"],
+    [0.55, "rgba(222,240,254,.55)"],
+    [1, "rgba(214,238,254,1)"]
+  ],
+  washEnabled: true,
+  pill: {
+    enabled: true,
+    width: 26,
+    height: 7,
+    rx: 3.5,
+    offsetY: -13,
+    gradient: [
+      [0, "#EFF7FF"],
+      [0.45, "#BBD9FF"],
+      [1, "#7FB2FF"]
+    ],
+    shadow: { width: 24, height: 1.4, rx: 0.7, offsetY: -7.5, color: "#4A78D8", opacity: 0.75 }
+  },
+  shadow: { dx: 0, dy: 3, blur: 5, color: "#1B3560", opacity: 0.14 },
+  fadeMask: { start: 344, end: 360 },
+  fadeEnabled: true,
+  labelY: 85,
+  numberY: 117,
+  labelXOffset: 0
+};
+var DEFAULT_THEME_TOKENS = {
+  fontFamily: '-apple-system,BlinkMacSystemFont,"Segoe UI","Inter","Helvetica Neue","PingFang SC","Microsoft YaHei",Arial,sans-serif',
+  title: { fill: "#14161F", fontSize: 21, fontWeight: 700, letterSpacing: "-0.2px" },
+  axis: { fill: "#9AA1AC", fontSize: 11, fontWeight: 500 },
+  label: { fill: "#C4CAD3", activeFill: "#242A36", fontSize: 11.5, fontWeight: 500 },
+  number: {
+    fill: "#C9CED6",
+    activeFill: "#15181F",
+    fontSize: 27,
+    fontWeight: 600,
+    letterSpacing: "-0.6px"
+  },
+  grid: { stroke: "#E9EBEF", strokeWidth: 1 },
+  tooltip: {
+    bg: "#fff",
+    stroke: "rgba(20,35,70,.07)",
+    fill: "#79839A",
+    strongFill: "#171B26",
+    softFill: "#C3C8D4",
+    fontSize: 10.5
+  },
+  transition: { state: ".32s ease", tip: "transform .34s cubic-bezier(.22,.61,.36,1)" }
+};
+function mergeStyleConfigs(base, top) {
+  if (!base) return top;
+  if (!top) return base;
+  return {
+    ...base,
+    ...top,
+    stripePattern: { ...base.stripePattern, ...top.stripePattern },
+    barGradient: { ...base.barGradient, ...top.barGradient },
+    pill: {
+      ...base.pill,
+      ...top.pill,
+      shadow: { ...base.pill?.shadow, ...top.pill?.shadow }
+    },
+    shadow: { ...base.shadow, ...top.shadow },
+    fadeMask: { ...base.fadeMask, ...top.fadeMask }
+  };
+}
+function resolveStyle(style, base) {
+  const merged = mergeStyleConfigs(base, style);
+  if (!merged) return DEFAULT_STYLE;
+  return {
+    stripePattern: { ...DEFAULT_STYLE.stripePattern, ...merged.stripePattern },
+    barGradientActive: merged.barGradient?.active ?? DEFAULT_STYLE.barGradientActive,
+    barGradientNormal: merged.barGradient?.normal ?? DEFAULT_STYLE.barGradientNormal,
+    foldGradient: merged.foldGradient ?? DEFAULT_STYLE.foldGradient,
+    creaseGradient: merged.creaseGradient ?? DEFAULT_STYLE.creaseGradient,
+    washTop: merged.washTop ?? DEFAULT_STYLE.washTop,
+    washGradient: merged.washGradient ?? DEFAULT_STYLE.washGradient,
+    washEnabled: merged.washEnabled ?? true,
+    pill: {
+      ...DEFAULT_STYLE.pill,
+      ...merged.pill,
+      gradient: merged.pill?.gradient ?? DEFAULT_STYLE.pill.gradient,
+      shadow: { ...DEFAULT_STYLE.pill.shadow, ...merged.pill?.shadow }
+    },
+    shadow: { ...DEFAULT_STYLE.shadow, ...merged.shadow },
+    fadeMask: { ...DEFAULT_STYLE.fadeMask, ...merged.fadeMask },
+    fadeEnabled: merged.fadeMask?.enabled ?? true,
+    labelY: merged.labelY ?? DEFAULT_STYLE.labelY,
+    numberY: merged.numberY ?? DEFAULT_STYLE.numberY,
+    labelXOffset: merged.labelXOffset ?? DEFAULT_STYLE.labelXOffset
+  };
+}
+function mergeTokens(base, top) {
+  if (!base) return top;
+  if (!top) return base;
+  return {
+    fontFamily: top.fontFamily ?? base.fontFamily,
+    title: { ...base.title, ...top.title },
+    axis: { ...base.axis, ...top.axis },
+    label: { ...base.label, ...top.label },
+    number: { ...base.number, ...top.number },
+    grid: { ...base.grid, ...top.grid },
+    tooltip: { ...base.tooltip, ...top.tooltip },
+    transition: { ...base.transition, ...top.transition }
+  };
+}
+function resolveTokens(theme) {
+  if (!theme) return DEFAULT_THEME_TOKENS;
+  return {
+    fontFamily: theme.fontFamily ?? DEFAULT_THEME_TOKENS.fontFamily,
+    title: { ...DEFAULT_THEME_TOKENS.title, ...theme.title },
+    axis: { ...DEFAULT_THEME_TOKENS.axis, ...theme.axis },
+    label: { ...DEFAULT_THEME_TOKENS.label, ...theme.label },
+    number: { ...DEFAULT_THEME_TOKENS.number, ...theme.number },
+    grid: { ...DEFAULT_THEME_TOKENS.grid, ...theme.grid },
+    tooltip: { ...DEFAULT_THEME_TOKENS.tooltip, ...theme.tooltip },
+    transition: { ...DEFAULT_THEME_TOKENS.transition, ...theme.transition }
+  };
+}
+function buildScopedCss(uid, tokens) {
+  const c = (name) => `.${uid}-${name}`;
+  return [
+    `${c("root")}{display:block;width:100%;height:auto;font-family:${tokens.fontFamily}}`,
+    `${c("title")}{font-size:${tokens.title.fontSize}px;font-weight:${tokens.title.fontWeight};fill:${tokens.title.fill};letter-spacing:${tokens.title.letterSpacing}}`,
+    `${c("axis")}{font-size:${tokens.axis.fontSize}px;font-weight:${tokens.axis.fontWeight};fill:${tokens.axis.fill};font-variant-numeric:tabular-nums}`,
+    `${c("lbl")}{font-size:${tokens.label.fontSize}px;font-weight:${tokens.label.fontWeight};fill:${tokens.label.fill};transition:fill .3s ease}`,
+    `${c("num")}{font-size:${tokens.number.fontSize}px;font-weight:${tokens.number.fontWeight};fill:${tokens.number.fill};letter-spacing:${tokens.number.letterSpacing};font-variant-numeric:tabular-nums;transition:fill .3s ease}`,
+    `${c("col")}.${uid}-active ${c("lbl")}{fill:${tokens.label.activeFill}}`,
+    `${c("col")}.${uid}-active ${c("num")}{fill:${tokens.number.activeFill}}`,
+    `${c("stripes")}{opacity:1;transition:opacity ${tokens.transition.state}}`,
+    `${c("col")}.${uid}-active ${c("stripes")}{opacity:0}`,
+    `${c("wash")}{opacity:0;transition:opacity ${tokens.transition.state}}`,
+    `${c("col")}.${uid}-active ${c("wash")}{opacity:1}`,
+    `${c("hit")}{fill:transparent;cursor:pointer}`,
+    `${c("tip")}{transition:${tokens.transition.tip};pointer-events:none}`,
+    `${c("tip")} text{font-size:${tokens.tooltip.fontSize}px;font-weight:400;fill:${tokens.tooltip.fill};font-variant-numeric:tabular-nums}`,
+    `${c("tip")} ${c("b")}{font-weight:700;fill:${tokens.tooltip.strongFill}}`,
+    `${c("tip")} ${c("s")}{fill:${tokens.tooltip.softFill}}`,
+    `@media (prefers-reduced-motion: reduce){${c("lbl")},${c("num")},${c("stripes")},${c("wash")},${c("tip")}{transition:none}}`
+  ].join("\n");
+}
+
+// src/theme/presets.ts
+function isThemePack(value) {
+  return "style" in value || "tokens" in value || "formats" in value;
+}
+var registry = /* @__PURE__ */ new Map();
+function registerTheme(name, pack) {
+  registry.set(name, pack);
+}
+function getTheme(name) {
+  return registry.get(name);
+}
+var DARK_STYLE = {
+  barGradient: {
+    normal: [
+      [0, "#5B8CFF"],
+      [0.07, "#4A7AF2"],
+      [0.22, "#3E68DE"],
+      [0.42, "#3255C2"],
+      [0.62, "#27408F"],
+      [0.82, "#1B2C5E"],
+      [1, "#111B3A"]
+    ],
+    active: [
+      [0, "#7BA2FF"],
+      [0.07, "#6A93F8"],
+      [0.22, "#5A80E8"],
+      [0.42, "#4A6ACC"],
+      [0.62, "#38529E"],
+      [0.82, "#263868"],
+      [1, "#172142"]
+    ]
+  },
+  foldGradient: [
+    [0, "#3A4E7E"],
+    [0.14, "#334572"],
+    [0.38, "#2A3A60"],
+    [0.68, "#1F2C4C"],
+    [1, "#18223C"]
+  ],
+  creaseGradient: [
+    [0, "rgba(255,255,255,0)"],
+    [0.18, "rgba(255,255,255,.28)"],
+    [0.55, "rgba(255,255,255,.10)"],
+    [1, "rgba(255,255,255,0)"]
+  ],
+  stripePattern: { lineColor: "#6E86B8", lineOpacity: 0.16 },
+  washGradient: [
+    [0, "rgba(96,146,255,0)"],
+    [0.55, "rgba(96,146,255,.24)"],
+    [1, "rgba(84,130,250,.48)"]
+  ],
+  pill: {
+    gradient: [
+      [0, "#4E669E"],
+      [0.45, "#3A507F"],
+      [1, "#2A3B61"]
+    ],
+    shadow: { color: "#000814", opacity: 0.8 }
+  },
+  shadow: { color: "#000000", opacity: 0.5 }
+};
+var DARK_TOKENS = {
+  title: { fill: "#F1F5FC" },
+  axis: { fill: "#5D6880" },
+  label: { fill: "#4E5871", activeFill: "#F1F5FC" },
+  number: { fill: "#566179", activeFill: "#FFFFFF" },
+  grid: { stroke: "#222C42" },
+  tooltip: {
+    bg: "#1A2236",
+    stroke: "rgba(255,255,255,.10)",
+    fill: "#93A0BC",
+    strongFill: "#FFFFFF",
+    softFill: "#46536F"
+  }
+};
+registerTheme("light", {});
+registerTheme("dark", { style: DARK_STYLE, tokens: DARK_TOKENS });
+
+// src/charts/fold-bar/defaults.ts
+var defaultValueFormat = (value) => `${value.toFixed(1)}k`;
+function defaultTooltipFormatter(datum) {
+  return [
+    { text: `${datum.label}  `, tone: "n" },
+    { text: defaultValueFormat(datum.value), tone: "b" }
+  ];
+}
+function cleanNumber(value) {
+  return Number(value.toPrecision(12));
+}
+function niceScale(maxValue, targetCount = 5) {
+  if (!Number.isFinite(maxValue) || maxValue <= 0) return { axisMax: 0, step: 0, ticks: [] };
+  const rawStep = maxValue / targetCount;
+  const power = Math.floor(Math.log10(rawStep));
+  const base = Math.pow(10, power);
+  const error = rawStep / base;
+  const multiplier = error >= Math.sqrt(50) ? 10 : error >= Math.sqrt(10) ? 5 : error >= Math.SQRT2 ? 2 : 1;
+  const step = cleanNumber(multiplier * base);
+  const axisMax = cleanNumber(Math.ceil(maxValue / step - 1e-9) * step);
+  const intervalCount = Math.round(axisMax / step);
+  const ascending = Array.from({ length: intervalCount }, (_, i) => cleanNumber((i + 1) * step));
+  return { axisMax, step, ticks: ascending.slice(-targetCount).reverse() };
+}
+function resolveThemeRef(theme) {
+  if (!theme) return {};
+  if (typeof theme === "string") {
+    const pack = getTheme(theme);
+    if (!pack) console.warn(`sk-chart: unknown theme "${theme}"; falling back to defaults`);
+    return { pack: pack ?? {} };
+  }
+  if (isThemePack(theme)) return { pack: theme };
+  return { userTokens: theme };
+}
+function resolveOptions(config) {
+  const width = config.width ?? 860;
+  const height = config.height ?? 386;
+  const yField = config.yField ?? "value";
+  const maxValue = config.data.reduce((max, d) => Math.max(max, Number(d[yField]) || 0), 0);
+  const rawExponent = config.scale?.exponent ?? 1;
+  let exponent = rawExponent;
+  if (!Number.isFinite(exponent) || exponent <= 0) {
+    console.warn(`sk-chart: invalid scale.exponent ${rawExponent}; falling back to 1`);
+    exponent = 1;
+  }
+  const requestedActive = config.state?.defaultActive ?? config.data.length - 1;
+  const defaultActive = Math.min(
+    Math.max(requestedActive, -1),
+    Math.max(0, config.data.length - 1)
+  );
+  const { pack, userTokens } = resolveThemeRef(config.theme);
+  const tokens = resolveTokens(mergeTokens(pack?.tokens, userTokens));
+  const nice = niceScale(maxValue);
+  const ticks = config.axis?.ticks ?? nice.ticks;
+  const domainMax = Math.max(nice.axisMax, maxValue, ...ticks);
+  const bottomLabels = config.xAxis?.bottomLabels;
+  const bottomRows = bottomLabels ? config.data.reduce((max, d, i) => {
+    const out = bottomLabels(d, i, config.data);
+    return Math.max(max, Array.isArray(out) ? out.length : 1);
+  }, 0) : 0;
+  const titleText = config.xAxis?.title?.text ?? "";
+  const axisRows = bottomRows + (titleText ? 1 : 0);
+  const rowHeight = tokens.axis.fontSize + 4;
+  const defaultBottom = axisRows > 0 ? Math.max(26, 32 + axisRows * rowHeight) : 26;
+  const xField = config.xField ?? "label";
+  return {
+    width,
+    height,
+    xField,
+    yField,
+    valueFormat: config.valueFormat ?? pack?.formats?.valueFormat ?? defaultValueFormat,
+    ariaLabel: config.ariaLabel ?? "fold bar chart",
+    padding: { top: 64, right: 29, bottom: defaultBottom, left: 73, ...config.padding },
+    stair: { bottomOffset: 30, topOffset: 74, ...config.stair },
+    scale: { exponent },
+    fold: {
+      run: config.fold?.run ?? 20,
+      creaseColor: config.fold?.creaseColor ?? "rgba(255,255,255,.85)",
+      creaseWidth: config.fold?.creaseWidth ?? 1.2
+    },
+    axis: {
+      ticks,
+      tickFormat: config.axis?.tickFormat ?? pack?.formats?.tickFormat ?? ((v) => `${v}k`),
+      domainMax
+    },
+    xAxis: {
+      labelFormat: config.xAxis?.labelFormat ?? ((d) => String(d[xField] ?? "")),
+      bottomLabels,
+      title: {
+        text: titleText,
+        x: config.xAxis?.title?.x,
+        y: config.xAxis?.title?.y
+      },
+      showLine: config.xAxis?.showLine ?? false,
+      showTick: config.xAxis?.showTick ?? false,
+      showGrid: config.xAxis?.showGrid ?? true
+    },
+    tooltip: {
+      enabled: config.tooltip?.enabled ?? true,
+      formatter: config.tooltip?.formatter ?? defaultTooltipFormatter,
+      height: config.tooltip?.height ?? 28,
+      radius: config.tooltip?.radius ?? 9,
+      paddingX: config.tooltip?.paddingX ?? 12,
+      anchorRatio: config.tooltip?.anchorRatio ?? 0.42,
+      offsetY: config.tooltip?.offsetY ?? -30,
+      minY: config.tooltip?.minY ?? 140,
+      fixedWidth: config.tooltip?.fixedWidth
+    },
+    state: { defaultActive },
+    title: {
+      text: config.title?.text ?? "",
+      x: config.title?.x ?? 36,
+      y: config.title?.y ?? 52
+    },
+    style: resolveStyle(config.style, pack?.style),
+    tokens
+  };
+}
+function createModel(config, options) {
+  const data = config.data;
+  const labels = data.map((d, i) => options.xAxis.labelFormat(d, i, data));
+  const raw = data.map((d) => Number(d[options.yField]));
+  if (raw.some((v) => Number.isNaN(v) || v < 0)) {
+    console.warn("sk-chart: FoldBarChart data contains NaN or negative values; they render as zero.");
+  }
+  const values = raw.map((v) => v || 0);
+  const layout = computeLayout({
+    width: options.width,
+    height: options.height,
+    padding: options.padding,
+    stairBottomOffset: options.stair.bottomOffset,
+    stairTopOffset: options.stair.topOffset,
+    foldRun: options.fold.run,
+    barGap: 1,
+    exponent: options.scale.exponent,
+    domainMax: options.axis.domainMax,
+    values
+  });
+  const bars = values.map((v, i) => barGeometry(layout, i, v));
+  const flaps = values.map((_, i) => flapGeometry(layout, i, values));
+  const fade = config.style?.fadeMask ? options.style.fadeMask : { start: layout.plot.bottom - 16, end: layout.plot.bottom };
+  return { data, labels, values, layout, bars, flaps, fade, options };
+}
+
+// src/charts/fold-bar/interaction.ts
+function measureTooltipText(text) {
+  text.setAttribute("x", "0");
+  text.setAttribute("y", "0");
+  let width = 0;
+  let centerY = 0;
+  if (typeof text.getComputedTextLength === "function") {
+    try {
+      width = text.getComputedTextLength();
+    } catch {
+      width = 0;
+    }
+  }
+  if (typeof text.getBBox === "function") {
+    try {
+      const box = text.getBBox();
+      centerY = box.y + box.height / 2;
+    } catch {
+      centerY = 0;
+    }
+  }
+  return { width, centerY };
+}
+function renderTooltipText(uid, text, parts) {
+  text.textContent = "";
+  for (const part of parts) {
+    const attrs = {};
+    if (part.tone && part.tone !== "n") {
+      attrs.class = scopedId(uid, part.tone);
+    }
+    const tspan = createSvgElement("tspan", attrs);
+    tspan.textContent = part.text;
+    text.appendChild(tspan);
+  }
+}
+function attachInteraction(ctx) {
+  const { uid, columns, columnsLayer, tooltip, model, host } = ctx;
+  const { options, layout, bars, data } = model;
+  let active = -1;
+  const cleanup = [];
+  function listen(target, type, fn, opts) {
+    target.addEventListener(type, fn, opts);
+    cleanup.push(() => target.removeEventListener(type, fn, opts));
+  }
+  function renderTip(index) {
+    if (!options.tooltip.enabled) return;
+    const parts = options.tooltip.formatter(data[index], index, data);
+    renderTooltipText(uid, tooltip.text, parts);
+    const measured = measureTooltipText(tooltip.text);
+    const width = options.tooltip.fixedWidth ?? measured.width + options.tooltip.paddingX * 2;
+    tooltip.rect.setAttribute("width", String(width));
+    tooltip.text.setAttribute("x", String(width / 2));
+    tooltip.text.setAttribute(
+      "y",
+      String(options.tooltip.height / 2 - measured.centerY)
+    );
+    const pos = tooltipPlacement(layout, bars[index], width, options.tooltip);
+    tooltip.group.setAttribute("transform", `translate(${pos.x},${pos.y})`);
+  }
+  function setActive(index) {
+    if (index === active || index < 0 || index >= columns.length) return;
+    active = index;
+    columns.forEach((col, i) => {
+      col.classList.toggle(`${uid}-active`, i === index);
+      col.setAttribute("aria-selected", String(i === index));
+    });
+    renderTip(index);
+  }
+  columns.forEach((col, i) => {
+    listen(col, "mouseenter", () => {
+      setActive(i);
+      host.emit("column:enter", { index: i, datum: data[i] });
+    });
+    listen(col, "click", () => {
+      host.emit("column:click", { index: i, datum: data[i] });
+    });
+    listen(col, "touchstart", () => setActive(i), { passive: true });
+  });
+  const releaseTouch = () => setActive(options.state.defaultActive);
+  listen(columnsLayer, "touchend", releaseTouch, { passive: true });
+  listen(columnsLayer, "touchcancel", releaseTouch, { passive: true });
+  listen(columnsLayer, "mouseleave", () => {
+    if (active >= 0) {
+      host.emit("column:leave", { index: active, datum: data[active] });
+    }
+    setActive(options.state.defaultActive);
+  });
+  const svg = columnsLayer.ownerSVGElement;
+  if (svg) {
+    svg.setAttribute("tabindex", "0");
+    listen(svg, "keydown", (event) => {
+      const key = event.key;
+      if (key === "ArrowRight") {
+        setActive(Math.min(active + 1, columns.length - 1));
+        event.preventDefault();
+      } else if (key === "ArrowLeft") {
+        setActive(Math.max(active - 1, 0));
+        event.preventDefault();
+      } else if (key === "Home") {
+        setActive(0);
+        event.preventDefault();
+      } else if (key === "End") {
+        setActive(columns.length - 1);
+        event.preventDefault();
+      } else if ((key === "Enter" || key === " ") && active >= 0) {
+        host.emit("column:click", { index: active, datum: data[active] });
+        event.preventDefault();
+      }
+    });
+  }
+  tooltip.group.style.transition = "none";
+  setActive(options.state.defaultActive);
+  requestAnimationFrame(() => {
+    tooltip.group.style.transition = "";
+  });
+  return {
+    setActive,
+    getActive: () => active,
+    destroy: () => cleanup.forEach((fn) => fn())
+  };
+}
+
+// src/charts/fold-bar/defs-builder.ts
+function buildDefs(ctx) {
+  const { uid, style } = ctx;
+  const defs = createSvgElement("defs");
+  if (style.stripePattern.enabled) {
+    const pattern = createSvgElement("pattern", {
+      id: scopedId(uid, "stripes"),
+      width: style.stripePattern.size,
+      height: style.stripePattern.size,
+      patternUnits: "userSpaceOnUse",
+      patternTransform: `rotate(${style.stripePattern.rotation})`
+    });
+    pattern.appendChild(
+      createSvgElement("rect", {
+        width: style.stripePattern.size,
+        height: style.stripePattern.size,
+        fill: "none"
+      })
+    );
+    pattern.appendChild(
+      createSvgElement("rect", {
+        width: style.stripePattern.lineWidth,
+        height: style.stripePattern.size,
+        fill: style.stripePattern.lineColor,
+        "fill-opacity": style.stripePattern.lineOpacity
+      })
+    );
+    defs.appendChild(pattern);
+  }
+  for (let i = 0; i < ctx.barCount; i++) {
+    const stops = i === ctx.gradientIndex ? style.barGradientActive : style.barGradientNormal;
+    defs.appendChild(
+      addStops(
+        createSvgElement("linearGradient", { id: scopedId(uid, `bar${i}`), x1: 0, y1: 0, x2: 0, y2: 1 }),
+        stops
+      )
+    );
+  }
+  for (let i = 0; i < ctx.barCount; i++) {
+    const range = ctx.flapGradientYs[i];
+    if (!range) continue;
+    defs.appendChild(
+      addStops(
+        createSvgElement("linearGradient", {
+          id: scopedId(uid, `fold${i}`),
+          gradientUnits: "userSpaceOnUse",
+          x1: 0,
+          y1: range[0],
+          x2: 0,
+          y2: range[1]
+        }),
+        style.foldGradient
+      )
+    );
+  }
+  defs.appendChild(
+    addStops(
+      createSvgElement("linearGradient", { id: scopedId(uid, "crease"), x1: 0, y1: 0, x2: 1, y2: 0 }),
+      style.creaseGradient
+    )
+  );
+  if (style.washEnabled) {
+    defs.appendChild(
+      addStops(
+        createSvgElement("linearGradient", { id: scopedId(uid, "wash"), x1: 0, y1: 0, x2: 0, y2: 1 }),
+        style.washGradient
+      )
+    );
+  }
+  if (style.pill.enabled) {
+    defs.appendChild(
+      addStops(
+        createSvgElement("linearGradient", { id: scopedId(uid, "pill"), x1: 0, y1: 0, x2: 0, y2: 1 }),
+        style.pill.gradient
+      )
+    );
+  }
+  const filter = createSvgElement("filter", {
+    id: scopedId(uid, "soft"),
+    x: "-40%",
+    y: "-40%",
+    width: "180%",
+    height: "200%"
+  });
+  filter.appendChild(
+    createSvgElement("feDropShadow", {
+      dx: style.shadow.dx,
+      dy: style.shadow.dy,
+      stdDeviation: style.shadow.blur,
+      "flood-color": style.shadow.color,
+      "flood-opacity": style.shadow.opacity
+    })
+  );
+  defs.appendChild(filter);
+  if (style.fadeEnabled) {
+    defs.appendChild(
+      addStops(
+        createSvgElement("linearGradient", {
+          id: scopedId(uid, "fadeGrad"),
+          gradientUnits: "userSpaceOnUse",
+          x1: 0,
+          y1: ctx.fade.start,
+          x2: 0,
+          y2: ctx.fade.end
+        }),
+        [
+          [0, "#fff"],
+          [1, "#000"]
+        ]
+      )
+    );
+    const mask = createSvgElement("mask", {
+      id: scopedId(uid, "fade"),
+      maskUnits: "userSpaceOnUse",
+      x: 0,
+      y: 0,
+      width: ctx.width,
+      height: ctx.height
+    });
+    mask.appendChild(
+      createSvgElement("rect", {
+        x: 0,
+        y: 0,
+        width: ctx.width,
+        height: ctx.height,
+        fill: urlRef(uid, "fadeGrad")
+      })
+    );
+    defs.appendChild(mask);
+  }
+  return defs;
+}
+
+// src/charts/fold-bar/render.ts
+function renderFoldBar(uid, model) {
+  const { options, layout, bars, flaps, labels, values, data } = model;
+  const { style, tokens } = options;
+  const svg = createSvgElement("svg", {
+    class: scopedId(uid, "root"),
+    viewBox: `0 0 ${options.width} ${options.height}`,
+    role: "img",
+    "aria-label": options.ariaLabel
+  });
+  const styleEl = createSvgElement("style");
+  styleEl.textContent = buildScopedCss(uid, tokens);
+  svg.appendChild(styleEl);
+  svg.appendChild(
+    buildDefs({
+      uid,
+      width: options.width,
+      height: options.height,
+      plotBottom: layout.plot.bottom,
+      barCount: values.length,
+      gradientIndex: options.state.defaultActive,
+      flapGradientYs: flaps.map((flap) => flap ? flap.gradientY : null),
+      fade: model.fade,
+      style
+    })
+  );
+  if (options.title.text) {
+    const title = createSvgElement("text", {
+      class: scopedId(uid, "title"),
+      x: options.title.x,
+      y: options.title.y
+    });
+    title.textContent = options.title.text;
+    svg.appendChild(title);
+  }
+  const grid = createSvgElement("g");
+  options.axis.ticks.forEach((tick) => {
+    const label = createSvgElement("text", {
+      class: scopedId(uid, "axis"),
+      x: layout.plot.left - 15,
+      y: layout.barTopOf(tick) + 4,
+      "text-anchor": "end"
+    });
+    label.textContent = options.axis.tickFormat(tick);
+    grid.appendChild(label);
+  });
+  if (options.xAxis.showGrid) {
+    for (const x of gridLineXs(layout)) {
+      grid.appendChild(
+        createSvgElement("line", {
+          x1: x,
+          x2: x,
+          y1: layout.plot.top,
+          y2: layout.plot.bottom,
+          stroke: tokens.grid.stroke,
+          "stroke-width": tokens.grid.strokeWidth
+        })
+      );
+    }
+  }
+  svg.appendChild(grid);
+  const columnsLayer = createSvgElement(
+    "g",
+    style.fadeEnabled ? { mask: urlRef(uid, "fade"), role: "list" } : { role: "list" }
+  );
+  svg.appendChild(columnsLayer);
+  const columns = [];
+  values.forEach((value, i) => {
+    const bar = bars[i];
+    const col = createSvgElement("g", {
+      class: scopedId(uid, "col"),
+      "data-i": i,
+      role: "listitem",
+      "aria-selected": "false",
+      "aria-label": `${labels[i]} ${options.valueFormat(value)}`
+    });
+    if (style.washEnabled) {
+      col.appendChild(
+        createSvgElement("rect", {
+          class: scopedId(uid, "wash"),
+          ...washRect(bar, style.washTop),
+          fill: urlRef(uid, "wash")
+        })
+      );
+    }
+    col.appendChild(
+      createSvgElement("rect", {
+        x: bar.x,
+        y: bar.y,
+        width: bar.width,
+        height: bar.height,
+        fill: urlRef(uid, `bar${i}`)
+      })
+    );
+    if (style.stripePattern.enabled) {
+      col.appendChild(
+        createSvgElement("rect", {
+          class: scopedId(uid, "stripes"),
+          x: bar.x,
+          y: bar.y,
+          width: bar.width,
+          height: bar.height,
+          fill: urlRef(uid, "stripes")
+        })
+      );
+    }
+    const flap = flaps[i];
+    if (flap) {
+      col.appendChild(
+        createSvgElement("polygon", { points: flap.points, fill: urlRef(uid, `fold${i}`) })
+      );
+      col.appendChild(
+        createSvgElement("polygon", { points: flap.points, fill: urlRef(uid, "crease") })
+      );
+      col.appendChild(
+        createSvgElement("line", {
+          x1: flap.crease.x1,
+          y1: flap.crease.y1,
+          x2: flap.crease.x2,
+          y2: flap.crease.y2,
+          stroke: options.fold.creaseColor,
+          "stroke-width": options.fold.creaseWidth
+        })
+      );
+    }
+    if (style.pill.enabled) {
+      const pill = pillGeometry(bar.centerX, bar.y, style.pill);
+      col.appendChild(
+        createSvgElement("rect", {
+          x: pill.x,
+          y: pill.y,
+          width: pill.width,
+          height: pill.height,
+          rx: pill.rx,
+          fill: urlRef(uid, "pill")
+        })
+      );
+      col.appendChild(
+        createSvgElement("rect", {
+          x: pill.shadowX,
+          y: pill.shadowY,
+          width: pill.shadowWidth,
+          height: pill.shadowHeight,
+          rx: pill.shadowRx,
+          fill: style.pill.shadow.color,
+          "fill-opacity": style.pill.shadow.opacity
+        })
+      );
+    }
+    const labelX = bar.centerX + style.labelXOffset;
+    const label = createSvgElement("text", {
+      class: scopedId(uid, "lbl"),
+      x: labelX,
+      y: style.labelY,
+      "text-anchor": "middle"
+    });
+    label.textContent = labels[i];
+    col.appendChild(label);
+    const num = createSvgElement("text", {
+      class: scopedId(uid, "num"),
+      x: labelX,
+      y: style.numberY,
+      "text-anchor": "middle"
+    });
+    num.textContent = options.valueFormat(value);
+    col.appendChild(num);
+    col.appendChild(
+      createSvgElement("rect", { class: scopedId(uid, "hit"), ...hitRect(layout, i) })
+    );
+    columnsLayer.appendChild(col);
+    columns.push(col);
+  });
+  const { xAxis } = options;
+  if (xAxis.showLine || xAxis.showTick || xAxis.bottomLabels || xAxis.title.text) {
+    const axisLayer = createSvgElement("g", {
+      class: scopedId(uid, "xaxis"),
+      "pointer-events": "none",
+      "aria-hidden": "true"
+    });
+    const axisLineY = layout.plot.bottom + 4;
+    if (xAxis.showLine) {
+      axisLayer.appendChild(
+        createSvgElement("line", {
+          x1: layout.plot.left,
+          x2: layout.plot.right,
+          y1: axisLineY,
+          y2: axisLineY,
+          stroke: tokens.grid.stroke,
+          "stroke-width": tokens.grid.strokeWidth
+        })
+      );
+    }
+    const rowHeight = tokens.axis.fontSize + 4;
+    if (xAxis.showTick) {
+      for (const x of gridLineXs(layout)) {
+        axisLayer.appendChild(
+          createSvgElement("line", {
+            x1: x,
+            x2: x,
+            y1: axisLineY,
+            y2: axisLineY + 4,
+            stroke: tokens.grid.stroke,
+            "stroke-width": tokens.grid.strokeWidth
+          })
+        );
+      }
+    }
+    let bottomRows = 0;
+    if (xAxis.bottomLabels) {
+      const format = xAxis.bottomLabels;
+      bars.forEach((bar, i) => {
+        const out = format(data[i], i, data);
+        const lines = Array.isArray(out) ? out : [out];
+        bottomRows = Math.max(bottomRows, lines.length);
+        lines.forEach((line, row) => {
+          const text2 = createSvgElement("text", {
+            class: scopedId(uid, "axis"),
+            x: bar.centerX,
+            y: layout.plot.bottom + 20 + row * rowHeight,
+            "text-anchor": "middle"
+          });
+          text2.textContent = line;
+          axisLayer.appendChild(text2);
+        });
+      });
+    }
+    if (xAxis.title.text) {
+      const title = createSvgElement("text", {
+        class: scopedId(uid, "axis"),
+        x: xAxis.title.x ?? (layout.plot.left + layout.plot.right) / 2,
+        y: xAxis.title.y ?? layout.plot.bottom + 26 + bottomRows * rowHeight,
+        "text-anchor": "middle"
+      });
+      title.textContent = xAxis.title.text;
+      axisLayer.appendChild(title);
+    }
+    svg.appendChild(axisLayer);
+  }
+  const group = createSvgElement("g", {
+    class: scopedId(uid, "tip"),
+    filter: urlRef(uid, "soft")
+  });
+  const rect = createSvgElement("rect", {
+    x: 0,
+    y: 0,
+    height: options.tooltip.height,
+    rx: options.tooltip.radius,
+    fill: tokens.tooltip.bg,
+    stroke: tokens.tooltip.stroke
+  });
+  const text = createSvgElement("text", { x: 0, y: 0, "text-anchor": "middle" });
+  group.appendChild(rect);
+  group.appendChild(text);
+  svg.appendChild(group);
+  return { svg, columns, columnsLayer, tooltip: { group, rect, text } };
+}
+
+// src/charts/fold-bar/index.ts
+var FoldBarChart = class extends ChartBase {
+  constructor(container, config) {
+    super(container, config);
+    this.uid = createUid();
+    this.model = null;
+    this.rendered = null;
+    this.interaction = null;
+    this.renderChart();
+  }
+  /** Currently active (highlighted) column index. */
+  get activeIndex() {
+    return this.interaction?.getActive() ?? -1;
+  }
+  /** Programmatically highlight a column. */
+  setActive(index) {
+    this.interaction?.setActive(index);
+  }
+  renderChart() {
+    this.interaction?.destroy();
+    this.interaction = null;
+    this.rendered?.svg.remove();
+    const options = resolveOptions(this.config);
+    this.model = createModel(this.config, options);
+    this.rendered = renderFoldBar(this.uid, this.model);
+    this.container.appendChild(this.rendered.svg);
+    this.svg = this.rendered.svg;
+    this.interaction = this.model.data.length ? attachInteraction({
+      uid: this.uid,
+      columns: this.rendered.columns,
+      columnsLayer: this.rendered.columnsLayer,
+      tooltip: this.rendered.tooltip,
+      model: this.model,
+      host: { emit: (event, payload) => this.emit(event, payload) }
+    }) : null;
+  }
+  onDestroy() {
+    this.interaction?.destroy();
+    this.interaction = null;
+  }
+};
+
+// src/scale/linear-scale.ts
+function createLinearScale({
+  domain: [d0, d1],
+  range: [r0, r1]
+}) {
+  const span = d1 - d0;
+  if (span === 0) return () => r0;
+  const k = (r1 - r0) / span;
+  return (value) => r0 + (value - d0) * k;
+}
+
+// src/scale/power-scale.ts
+function createPowerScale({
+  domain: [d0, d1],
+  range: [r0, r1],
+  exponent = 1
+}) {
+  const span = d1 - d0;
+  if (span === 0) return () => r0;
+  return (value) => {
+    const t = Math.max(0, (value - d0) / span);
+    return r0 + Math.pow(t, exponent) * (r1 - r0);
+  };
+}
+
+// src/scale/band-scale.ts
+function createBandScale(count, range, paddingRatio = 0) {
+  const [r0, r1] = range;
+  const step = count > 0 ? (r1 - r0) / count : 0;
+  const bandwidth = step * (1 - paddingRatio);
+  const offset = (step - bandwidth) / 2;
+  return {
+    step,
+    bandwidth,
+    position: (index) => r0 + index * step + offset,
+    center: (index) => r0 + index * step + step / 2
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChartBase,
+  FoldBarChart,
+  VERSION,
+  createBandScale,
+  createLinearScale,
+  createPowerScale,
+  defaultTooltipFormatter,
+  defaultValueFormat,
+  getTheme,
+  isThemePack,
+  niceScale,
+  registerTheme
+});
+//# sourceMappingURL=index.cjs.map