@fasl-work/caos-app-shell 0.18.0 → 0.19.0

package/dist/chunk-3LONJM5B.js

@@ -0,0 +1,680 @@
+import { LANG_STORAGE_KEY, THEME_STORAGE_KEY } from './chunk-33WTUQ7Q.js';
+import { create } from 'zustand';
+import { useMemo, useState, useRef, useCallback, useEffect } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var KEY = LANG_STORAGE_KEY;
+function readLang() {
+  try {
+    const s = localStorage.getItem(KEY);
+    if (s === "en" || s === "es") return s;
+  } catch {
+  }
+  return "en";
+}
+var useLangStore = create((set, get) => ({
+  lang: readLang(),
+  setLang: (l) => {
+    try {
+      localStorage.setItem(KEY, l);
+    } catch {
+    }
+    set({ lang: l });
+  },
+  toggle: () => {
+    const next = get().lang === "en" ? "es" : "en";
+    try {
+      localStorage.setItem(KEY, next);
+    } catch {
+    }
+    set({ lang: next });
+  }
+}));
+var useShellLang = () => useLangStore((s) => s.lang);
+
+// src/lib/text.ts
+function pick(text, lang) {
+  if (text === void 0) return "";
+  if (typeof text === "string") return text;
+  return text[lang] ?? text.en;
+}
+var KEY2 = THEME_STORAGE_KEY;
+function readTheme() {
+  try {
+    const s = localStorage.getItem(KEY2);
+    if (s === "light" || s === "dark") return s;
+    return window.matchMedia("(prefers-color-scheme: light)").matches ? "light" : "dark";
+  } catch {
+    return "dark";
+  }
+}
+function applyTheme(t) {
+  try {
+    document.documentElement.dataset.theme = t;
+  } catch {
+  }
+}
+var useThemeStore = create((set, get) => ({
+  theme: readTheme(),
+  toggleTheme: () => {
+    const next = get().theme === "dark" ? "light" : "dark";
+    applyTheme(next);
+    try {
+      localStorage.setItem(KEY2, next);
+    } catch {
+    }
+    set({ theme: next });
+  },
+  setTheme: (t) => {
+    applyTheme(t);
+    try {
+      localStorage.setItem(KEY2, t);
+    } catch {
+    }
+    set({ theme: t });
+  }
+}));
+var SHELL_TOKENS = [
+  "--color-bg",
+  "--color-surface",
+  "--color-surface-2",
+  "--color-border",
+  "--color-fg",
+  "--color-fg-subtle",
+  "--color-fg-faint",
+  "--color-accent",
+  "--color-accent-fg",
+  "--color-accent-soft",
+  "--color-accent-2",
+  "--color-magenta",
+  "--color-good",
+  "--color-warn",
+  "--color-bad",
+  "--color-shadow",
+  "--font-sans",
+  "--font-mono",
+  "--text-xs",
+  "--text-sm",
+  "--text-md",
+  "--text-base",
+  "--text-lg",
+  "--text-xl",
+  "--text-2xl",
+  "--space-1",
+  "--space-2",
+  "--space-3",
+  "--space-4",
+  "--space-5",
+  "--space-6",
+  "--radius-sm",
+  "--radius-md",
+  "--radius-lg",
+  "--radius-pill",
+  "--maxw",
+  "--maxw-wide",
+  "--measure",
+  "--measure-text",
+  "--header-h",
+  "--rail-w",
+  "--fade",
+  "--icon-sm",
+  "--icon-md",
+  "--icon-lg",
+  "--z-header",
+  "--z-focus",
+  "--z-modal"
+];
+function resolveToken(token, fallback = "") {
+  if (typeof document === "undefined") return fallback;
+  const v = getComputedStyle(document.documentElement).getPropertyValue(token).trim();
+  return v || fallback;
+}
+function useThemeTokens() {
+  const theme = useThemeStore((s) => s.theme);
+  return useMemo(() => {
+    const out = {};
+    for (const t of SHELL_TOKENS) out[t] = resolveToken(t);
+    return out;
+  }, [theme]);
+}
+
+// src/lib/format.ts
+var LOCALE = { en: "en-US", es: "es-CL" };
+var NBSP = "\xA0";
+var SCIENTIFIC_BELOW = 1e-4;
+function belowScientific(magnitude) {
+  return magnitude !== 0 && Math.abs(magnitude) < SCIENTIFIC_BELOW * (1 - 1e-12);
+}
+var NOT_AVAILABLE = { en: "not available", es: "no disponible" };
+function formatNumber(value, lang, opts = {}) {
+  if (value === null || value === void 0 || !Number.isFinite(value)) return NOT_AVAILABLE[lang];
+  const v = opts.percent ? value * 100 : value;
+  const digits = opts.digits ?? 4;
+  const scientific = v !== 0 && (opts.notation === "scientific" || belowScientific(v));
+  const grouping = opts.grouping === false ? { useGrouping: false } : {};
+  const nf = opts.decimals !== void 0 ? new Intl.NumberFormat(LOCALE[lang], { minimumFractionDigits: opts.decimals, maximumFractionDigits: opts.decimals, ...grouping }) : scientific ? new Intl.NumberFormat(LOCALE[lang], { notation: "scientific", maximumSignificantDigits: digits }) : Math.abs(v) >= 10 ** (digits - 1) ? new Intl.NumberFormat(LOCALE[lang], { maximumFractionDigits: 0, ...grouping }) : new Intl.NumberFormat(LOCALE[lang], { maximumSignificantDigits: digits, ...grouping });
+  return opts.percent ? `${nf.format(v)}${NBSP}%` : nf.format(v);
+}
+function formatTicks(values, lang, opts = {}) {
+  let o = opts;
+  if (opts.decimals === void 0 && opts.notation === void 0) {
+    const scale = opts.percent ? 100 : 1;
+    const small = values.some((v) => v !== null && v !== void 0 && Number.isFinite(v) && belowScientific(v * scale));
+    if (small) o = { ...opts, notation: "scientific" };
+  }
+  return values.map((v) => v === null || v === void 0 ? "" : formatNumber(v, lang, o));
+}
+function useFormat() {
+  const lang = useShellLang();
+  return (value, opts) => formatNumber(value, lang, opts);
+}
+function useStageSize() {
+  const [size, setSize] = useState({ width: 0, height: 0 });
+  const roRef = useRef(null);
+  const ref = useCallback((el) => {
+    roRef.current?.disconnect();
+    roRef.current = null;
+    if (!el) return;
+    const measure = () => {
+      const r = el.getBoundingClientRect();
+      setSize((prev) => prev.width === Math.round(r.width) && prev.height === Math.round(r.height) ? prev : { width: Math.round(r.width), height: Math.round(r.height) });
+    };
+    measure();
+    if (typeof ResizeObserver !== "undefined") {
+      roRef.current = new ResizeObserver(measure);
+      roRef.current.observe(el);
+    }
+  }, []);
+  useEffect(() => () => roRef.current?.disconnect(), []);
+  return [ref, size];
+}
+function Stage({ label, children, className }) {
+  const lang = useShellLang();
+  const [ref, size] = useStageSize();
+  const ready = size.width > 0 && size.height > 0;
+  const name = pick(label, lang);
+  useEffect(() => {
+    if (ready) return;
+    const t = setTimeout(() => {
+      console.error(`[caos-app-shell] Stage "${name}" has no size; give its container a height (ADR-0071 rule 8)`);
+    }, 1500);
+    return () => clearTimeout(t);
+  }, [ready, name]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      className: ["caos-stage", className].filter(Boolean).join(" "),
+      "data-stage": name,
+      "data-drawn": ready ? "1" : "0",
+      "data-width": size.width,
+      "data-height": size.height,
+      children: ready ? children(size) : null
+    }
+  );
+}
+
+// src/chart/text.ts
+function referenceLineName(lang, n, of) {
+  const base = lang === "es" ? "L\xEDnea de referencia" : "Reference line";
+  return of > 1 ? `${base} ${n}` : base;
+}
+var context;
+function fontFamily() {
+  if (typeof document === "undefined") return "sans-serif";
+  return getComputedStyle(document.documentElement).getPropertyValue("--font-sans").trim() || "sans-serif";
+}
+function textWidth(text, px, weight = 400) {
+  if (context === void 0) {
+    try {
+      context = typeof document === "undefined" ? null : document.createElement("canvas").getContext("2d");
+    } catch {
+      context = null;
+    }
+  }
+  if (!context) return text.length * px * 0.62;
+  context.font = `${weight} ${px}px ${fontFamily()}`;
+  return context.measureText(text).width;
+}
+function widestLabel(labels, px, weight = 400) {
+  return Math.max(0, ...labels.map((label) => textWidth(label, px, weight)));
+}
+function shorten(line, width, px) {
+  if (textWidth(line, px) <= width) return line;
+  let cut = line;
+  while (cut.length > 1 && textWidth(`${cut}\u2026`, px) > width) cut = cut.slice(0, -1);
+  return `${cut.trimEnd()}\u2026`;
+}
+function fitLabel(label, width, px, maxLines = 2) {
+  if (textWidth(label, px) <= width) return { lines: [label], shortened: false };
+  const words = label.split(" ");
+  if (maxLines === 2 && words.length > 1) {
+    let best = null;
+    let bestWidth = Infinity;
+    for (let k = 1; k < words.length; k += 1) {
+      const first = words.slice(0, k).join(" ");
+      const second = words.slice(k).join(" ");
+      const widest = Math.max(textWidth(first, px), textWidth(second, px));
+      if (widest < bestWidth) {
+        bestWidth = widest;
+        best = [first, second];
+      }
+    }
+    if (best && bestWidth <= width) return { lines: best, shortened: false };
+    if (best) return { lines: [shorten(best[0], width, px), shorten(best[1], width, px)], shortened: true };
+  }
+  return { lines: [shorten(label, width, px)], shortened: true };
+}
+function niceStep(x) {
+  if (!(x > 0) || !Number.isFinite(x)) return 1;
+  const magnitude = 10 ** Math.floor(Math.log10(x));
+  return ([1, 2, 2.5, 5, 10].find((m) => m * magnitude >= x * (1 - 1e-12)) ?? 10) * magnitude;
+}
+function niceStepAt(x, resolution = 0) {
+  if (!(resolution > 0)) return niceStep(x);
+  if (!(x > 0) || !Number.isFinite(x)) return resolution;
+  const start = Math.floor(Math.log10(Math.min(x, resolution))) - 1;
+  for (let e = start; e < start + 40; e++) {
+    for (const m of [1, 2, 2.5, 5]) {
+      const step = Number((m * 10 ** e).toPrecision(12));
+      const ratio = step / resolution;
+      if (step >= x * (1 - 1e-12) && step >= resolution * (1 - 1e-9) && Math.abs(ratio - Math.round(ratio)) < 1e-6) return step;
+    }
+  }
+  return Math.max(x, resolution);
+}
+function niceTicks(lo, hi, room, labelSize, most = 6, resolution = 0) {
+  if (!Number.isFinite(lo) || !Number.isFinite(hi)) return [0];
+  if (hi < lo) [lo, hi] = [hi, lo];
+  if (hi === lo) hi = lo === 0 ? 1 : lo + Math.abs(lo);
+  const count = Math.max(2, Math.min(most, Math.floor(room / (labelSize + 16)) + 1));
+  const step = niceStepAt((hi - lo) / (count - 1), resolution);
+  const first = Math.floor(lo / step + 1e-9) * step;
+  const ticks = [];
+  for (let k = 0; first + k * step <= hi + step * 1e-9 || ticks.length < 2; k += 1) {
+    ticks.push(Number((first + k * step).toPrecision(12)));
+    if (ticks.length > 50) break;
+  }
+  if (ticks[ticks.length - 1] < hi - step * 1e-9) ticks.push(Number((ticks[ticks.length - 1] + step).toPrecision(12)));
+  return ticks;
+}
+function repeatedLabels(labels) {
+  let n = 0;
+  for (let i = 1; i < labels.length; i++) if (labels[i] && labels[i] === labels[i - 1]) n++;
+  return n;
+}
+function ChartSummary({ id, text }) {
+  return /* @__PURE__ */ jsx("p", { id, className: "caos-chart-summary sr-only", children: text });
+}
+function ChartDataTable({ id, caption, head, rows }) {
+  return /* @__PURE__ */ jsx("div", { className: "sr-only", "data-chart-table-box": "", children: /* @__PURE__ */ jsxs("table", { id, className: "caos-chart-table", "data-chart-table": "", children: [
+    /* @__PURE__ */ jsx("caption", { children: caption }),
+    /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: head.map((h, i) => /* @__PURE__ */ jsx("th", { scope: "col", children: h }, i)) }) }),
+    /* @__PURE__ */ jsx("tbody", { children: rows.map((row, r) => /* @__PURE__ */ jsx("tr", { children: row.map((cell, c) => c === 0 ? /* @__PURE__ */ jsx("th", { scope: "row", children: cell }, c) : /* @__PURE__ */ jsx("td", { children: cell }, c)) }, r)) })
+  ] }) });
+}
+var RESET_ZOOM = { en: "Reset zoom", es: "Restablecer zoom" };
+function ResetZoomButton({ lang, onReset }) {
+  return /* @__PURE__ */ jsx("button", { type: "button", className: "caos-chart-reset", "data-chart-reset": "", onClick: onReset, children: RESET_ZOOM[lang] });
+}
+var CHART_ROLE = { en: "interactive chart", es: "gr\xE1fico interactivo" };
+var ZOOM_HINT = {
+  en: "Drag to zoom, click then scroll to zoom, double-click to reset; arrow keys read the values",
+  es: "Arrastre para acercar, haga clic y desplace para acercar, doble clic para restablecer; las flechas leen los valores"
+};
+
+// src/chart/interaction.ts
+var MIN_SPAN_SHARE = 1e-3;
+var WHEEL_RATE = 15e-4;
+var KEY_ZOOM = 0.7;
+var KEY_PAN = 0.1;
+var DRAG_THRESHOLD = 5;
+var forward = (v, log) => log ? Math.log10(v) : v;
+var back = (v, log) => log ? 10 ** v : v;
+function logOk(log, ...ranges) {
+  return Boolean(log) && ranges.every((r) => r[0] > 0 && r[1] > 0);
+}
+function zoomRange(cur, full, anchor, factor, opts = {}) {
+  const log = logOk(opts.log, cur, full) && anchor > 0;
+  const c0 = forward(Math.min(cur[0], cur[1]), log);
+  const c1 = forward(Math.max(cur[0], cur[1]), log);
+  const f0 = forward(Math.min(full[0], full[1]), log);
+  const f1 = forward(Math.max(full[0], full[1]), log);
+  const fullSpan = f1 - f0;
+  if (!(fullSpan > 0) || !Number.isFinite(factor) || !(factor > 0) || !Number.isFinite(anchor)) return [full[0], full[1]];
+  const span = c1 - c0 > 0 ? c1 - c0 : fullSpan;
+  const least = Math.min(fullSpan, opts.minSpan !== void 0 ? forward(opts.minSpan, false) : fullSpan * MIN_SPAN_SHARE);
+  const next = Math.min(fullSpan, Math.max(least, span * factor));
+  if (next >= fullSpan * (1 - 1e-9)) return [full[0], full[1]];
+  const a = forward(anchor, log);
+  const share = Math.min(1, Math.max(0, (a - c0) / span));
+  let lo = a - share * next;
+  let hi = lo + next;
+  if (lo < f0) {
+    hi += f0 - lo;
+    lo = f0;
+  }
+  if (hi > f1) {
+    lo -= hi - f1;
+    hi = f1;
+  }
+  return [back(Math.max(f0, lo), log), back(Math.min(f1, hi), log)];
+}
+function panRange(cur, full, share, log = false) {
+  const lg = logOk(log, cur, full);
+  const c0 = forward(Math.min(cur[0], cur[1]), lg);
+  const c1 = forward(Math.max(cur[0], cur[1]), lg);
+  const f0 = forward(Math.min(full[0], full[1]), lg);
+  const f1 = forward(Math.max(full[0], full[1]), lg);
+  const span = c1 - c0;
+  if (!(span > 0) || span >= f1 - f0 || !Number.isFinite(share)) return [cur[0], cur[1]];
+  const lo = Math.min(f1 - span, Math.max(f0, c0 + share * span));
+  return [back(lo, lg), back(lo + span, lg)];
+}
+function revealValue(cur, full, value, log = false) {
+  if (value >= Math.min(cur[0], cur[1]) && value <= Math.max(cur[0], cur[1])) return [cur[0], cur[1]];
+  const lg = logOk(log, cur, full) && value > 0;
+  const mid = (forward(cur[0], lg) + forward(cur[1], lg)) / 2;
+  return panRange(cur, full, (forward(value, lg) - mid) / (forward(cur[1], lg) - forward(cur[0], lg) || 1), log);
+}
+function isZoomed(cur, full) {
+  const tol = Math.abs(full[1] - full[0]) * 1e-9;
+  return Math.abs(cur[0] - full[0]) > tol || Math.abs(cur[1] - full[1]) > tol;
+}
+function wheelFactor(deltaY, deltaMode = 0) {
+  const px = deltaMode === 1 ? deltaY * 16 : deltaMode === 2 ? deltaY * 400 : deltaY;
+  return Math.exp(Math.max(-600, Math.min(600, px)) * WHEEL_RATE);
+}
+function keyAction(key, mods = {}) {
+  if (mods.ctrl || mods.meta || mods.alt) return null;
+  const arrow = key === "ArrowLeft" || key === "ArrowUp" ? -1 : key === "ArrowRight" || key === "ArrowDown" ? 1 : 0;
+  if (arrow !== 0) return mods.shift ? arrow < 0 ? "panPrev" : "panNext" : arrow < 0 ? "prev" : "next";
+  switch (key) {
+    case "Home":
+      return "first";
+    case "End":
+      return "last";
+    case "+":
+    case "=":
+      return "zoomIn";
+    case "-":
+    case "_":
+      return "zoomOut";
+    case "0":
+    case "Escape":
+      return "reset";
+    case "Enter":
+    case " ":
+      return "activate";
+    default:
+      return null;
+  }
+}
+function stepIndex(i, action, n) {
+  if (n <= 0) return null;
+  if (action === "first") return 0;
+  if (action === "last") return n - 1;
+  if (i === null || i < 0 || i >= n) return action === "next" ? 0 : n - 1;
+  return Math.min(n - 1, Math.max(0, i + (action === "next" ? 1 : -1)));
+}
+function firstVisible(xs, lo, hi) {
+  for (let i = 0; i < xs.length; i++) if (xs[i] >= lo && xs[i] <= hi) return i;
+  return null;
+}
+function roundWindow(r, n, minCount = 2) {
+  const count = Math.min(n, Math.max(1, minCount));
+  let s = Math.max(0, Math.min(n - count, Math.round(r[0])));
+  let e = Math.min(n, Math.max(s + count, Math.round(r[1])));
+  if (e - s < count) s = Math.max(0, e - count);
+  return [s, e];
+}
+function stepWindow(cur, n, anchor, factor, minCount = 2) {
+  const least = Math.min(n, Math.max(1, minCount));
+  const span = cur[1] - cur[0];
+  let w = roundWindow(zoomRange(cur, [0, n], anchor, factor, { minSpan: least }), n, least);
+  const share = span > 0 ? (anchor - cur[0]) / span : 0.5;
+  if (factor < 1 && w[1] - w[0] >= span && span > least) w = share < 0.5 ? [cur[0], cur[1] - 1] : [cur[0] + 1, cur[1]];
+  else if (factor > 1 && w[1] - w[0] <= span && span < n) w = share >= 0.5 && cur[0] > 0 || cur[1] >= n ? [cur[0] - 1, cur[1]] : [cur[0], cur[1] + 1];
+  return roundWindow(w, n, least);
+}
+function windowRange(n, win) {
+  return win ? roundWindow(win, n) : [0, n];
+}
+function categoryAt(pos, start, end, win, n) {
+  if (!(end > start) || pos < start || pos > end) return null;
+  const [s, e] = windowRange(n, win);
+  const k = Math.min(e - s - 1, Math.floor((pos - start) / (end - start) * (e - s)));
+  return s + Math.max(0, k);
+}
+function brushWindow(a, b, start, end, win, n) {
+  if (!(end > start)) return null;
+  const lo = Math.max(start, Math.min(a, b));
+  const hi = Math.min(end, Math.max(a, b));
+  const first = categoryAt(lo, start, end, win, n);
+  const last = categoryAt(Math.min(hi, end - 1e-9), start, end, win, n);
+  if (first === null || last === null) return null;
+  return roundWindow([first, last + 1], n);
+}
+function windowZoomed(n, win) {
+  if (!win) return false;
+  const [s, e] = windowRange(n, win);
+  return s > 0 || e < n;
+}
+function pinchState(a, b) {
+  return { dist: Math.hypot(a.x - b.x, a.y - b.y), mx: (a.x + b.x) / 2, my: (a.y + b.y) / 2 };
+}
+function axisTitleFits(title, room, px = 11) {
+  return textWidth(title, px) <= Math.max(0, room);
+}
+function wrapLines(text, width, px = 11) {
+  const words = text.split(/\s+/).filter(Boolean);
+  const lines = [];
+  let line = "";
+  const push = (word) => {
+    let rest = word;
+    while (textWidth(rest, px) > width && rest.length > 1) {
+      let cut = rest.length - 1;
+      while (cut > 1 && textWidth(rest.slice(0, cut), px) > width) cut -= 1;
+      lines.push(rest.slice(0, cut));
+      rest = rest.slice(cut);
+    }
+    line = rest;
+  };
+  for (const word of words) {
+    const tryLine = line ? `${line} ${word}` : word;
+    if (!line || textWidth(tryLine, px) <= width) {
+      if (!line && textWidth(word, px) > width) push(word);
+      else line = tryLine;
+    } else {
+      lines.push(line);
+      line = "";
+      if (textWidth(word, px) > width) push(word);
+      else line = word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines.length > 0 ? lines : [""];
+}
+function thinRows(n, most = 1e3) {
+  if (n <= most) return Array.from({ length: n }, (_, i) => i);
+  const step = Math.ceil(n / most);
+  const rows = [];
+  for (let i = 0; i < n; i += step) rows.push(i);
+  if (rows[rows.length - 1] !== n - 1) rows.push(n - 1);
+  return rows;
+}
+function allIntegers(values) {
+  return values.every((v) => v === null || v === void 0 || !Number.isFinite(v) || Number.isInteger(v));
+}
+function sameData(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let k = 0; k < a.length; k++) {
+    const x = a[k];
+    const y = b[k];
+    if (x === y) continue;
+    if (x.length !== y.length) return false;
+    for (let i = 0; i < x.length; i++) {
+      const u = x[i];
+      const v = y[i];
+      if (u === v) continue;
+      const mu = u === null || u === void 0 || !Number.isFinite(u);
+      const mv = v === null || v === void 0 || !Number.isFinite(v);
+      if (mu && mv) continue;
+      return false;
+    }
+  }
+  return true;
+}
+function leastLabelSpan(fmt, full, plotPx, spacePx) {
+  if (fmt && fmt.decimals !== void 0) return 0;
+  const scale = fmt?.percent ? 100 : 1;
+  const digits = fmt?.digits ?? 4;
+  const top = Math.max(Math.abs(full[0]), Math.abs(full[1])) * scale;
+  if (!(top > 0) || !Number.isFinite(top) || top < SCIENTIFIC_FLOOR) return 0;
+  const res = top >= 10 ** (digits - 1) ? 1 : 10 ** (Math.floor(Math.log10(top)) - digits + 1);
+  return res * (Math.ceil(Math.max(0, plotPx) / Math.max(1, spacePx)) + 1) / scale;
+}
+var SCIENTIFIC_FLOOR = 1e-4;
+function formatTime(seconds, lang, spanSeconds) {
+  const short = spanSeconds < 3 * 86400;
+  const opts = short ? { year: "numeric", month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" } : { year: "numeric", month: "short", day: "numeric" };
+  return new Intl.DateTimeFormat(lang === "es" ? "es-CL" : "en-US", opts).format(new Date(seconds * 1e3));
+}
+function brushRange(sel, full, least) {
+  const f0 = Math.min(full[0], full[1]);
+  const f1 = Math.max(full[0], full[1]);
+  if (least >= f1 - f0) return [f0, f1];
+  let lo = Math.max(f0, Math.min(sel[0], sel[1]));
+  let hi = Math.min(f1, Math.max(sel[0], sel[1]));
+  if (hi - lo < least) {
+    const mid = (lo + hi) / 2;
+    lo = mid - least / 2;
+    hi = mid + least / 2;
+    if (lo < f0) {
+      hi += f0 - lo;
+      lo = f0;
+    }
+    if (hi > f1) {
+      lo -= hi - f1;
+      hi = f1;
+    }
+  }
+  return [lo, hi];
+}
+function chartSummary(lang, p) {
+  const es = lang === "es";
+  const parts = [];
+  if (p.kind === "bars") parts.push(es ? `Gr\xE1fico de barras, ${p.name}: ${p.count} barras` : `Bar chart, ${p.name}: ${p.count} bars`);
+  else parts.push(es ? `Gr\xE1fico de l\xEDneas, ${p.name}: ${p.count} puntos` : `Line chart, ${p.name}: ${p.count} points`);
+  if (p.series && p.series.length > 0) parts.push(es ? `${p.series.length === 1 ? "serie" : "series"} ${p.series.join(", ")}` : `${p.series.length === 1 ? "series" : "series"} ${p.series.join(", ")}`);
+  if (p.xLabel && p.xFrom !== void 0 && p.xTo !== void 0) parts.push(es ? `${p.xLabel} de ${p.xFrom} a ${p.xTo}` : `${p.xLabel} from ${p.xFrom} to ${p.xTo}`);
+  if (p.first && p.last) {
+    const axis = p.yLabel ? `${p.yLabel}: ` : "";
+    parts.push(es ? `${axis}de ${p.first.text} en ${p.first.at} a ${p.last.text} en ${p.last.at}` : `${axis}from ${p.first.text} at ${p.first.at} to ${p.last.text} at ${p.last.at}`);
+  } else if (p.low && p.high) {
+    const axis = p.yLabel ? `${p.yLabel}: ` : "";
+    parts.push(es ? `${axis}m\xEDnimo ${p.low.text} en ${p.low.at}, m\xE1ximo ${p.high.text} en ${p.high.at}` : `${axis}lowest ${p.low.text} at ${p.low.at}, highest ${p.high.text} at ${p.high.at}`);
+  }
+  return `${parts.join(". ")}.`;
+}
+function defaultChartName(lang, yLabel, xLabel) {
+  return lang === "es" ? `${yLabel} seg\xFAn ${xLabel}` : `${yLabel} by ${xLabel}`;
+}
+function barExtent(value, span) {
+  if (value === null || value === void 0 || !Number.isFinite(value)) return null;
+  if (!span) return { a: 0, b: value, dot: false, given: false };
+  const [a, b] = span;
+  if (a === null || a === void 0 || b === null || b === void 0 || !Number.isFinite(a) || !Number.isFinite(b)) return null;
+  return { a, b, dot: a === b, given: true };
+}
+function clipExtent(e, lo, hi, all = false) {
+  if (!e || !e.given && !all) return e;
+  if (Math.max(e.a, e.b) < lo || Math.min(e.a, e.b) > hi) return null;
+  const c = (v) => Math.min(hi, Math.max(lo, v));
+  return { ...e, a: c(e.a), b: c(e.b) };
+}
+function bandsOf(groups) {
+  const out = [];
+  groups.forEach((g, i) => {
+    const last = out[out.length - 1];
+    if (g !== null && g !== void 0 && last && last.group === g && last.to === i) last.to = i + 1;
+    else out.push({ from: i, to: i + 1, ...g !== null && g !== void 0 ? { group: g } : {} });
+  });
+  return out;
+}
+var GROUP_MARGIN = 0.1;
+function memberSlots(count, most) {
+  const size = (1 - 2 * GROUP_MARGIN) / Math.max(1, most);
+  return { size, start: 0.5 - count * size / 2 };
+}
+function memberAt(frac, count, most) {
+  const { size, start } = memberSlots(count, most);
+  return Math.max(0, Math.min(count - 1, Math.floor((frac - start) / size)));
+}
+function unusedLegendTones(used, legend) {
+  const set = new Set(used);
+  return [...new Set(legend.map((l) => l.tone))].filter((t) => !set.has(t));
+}
+function boxesOverlap(a, b) {
+  return a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1;
+}
+function countOverlaps(boxes) {
+  let n = 0;
+  for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) if (boxesOverlap(boxes[i], boxes[j])) n += 1;
+  return n;
+}
+function ellipsize(text, k) {
+  return `${text.slice(0, Math.max(0, k)).trimEnd()}\u2026`;
+}
+function placeXLabel(text, s) {
+  const clear = (x0, w, y) => x0 >= s.left - 1e-6 && x0 + w <= s.right + 1e-6 && !s.boxes.some((b) => x0 < b.x1 + s.gap && x0 + w + s.gap > b.x0 && y - s.textH < b.y1 && y > b.y0);
+  const primary = (w) => {
+    let x0 = s.px + s.gap;
+    if (x0 + w > s.right) x0 = s.px - s.gap - w;
+    if (x0 < s.left) x0 = Math.max(s.left, Math.min(s.right - w, s.px - w / 2));
+    return x0;
+  };
+  const others = (w) => [s.px - s.gap - w, s.px + s.gap, Math.max(s.left, Math.min(s.right - w, s.px - w / 2))];
+  const attempt = (candidate) => {
+    const w = s.measure(candidate);
+    for (const pass of [[primary(w)], others(w)]) {
+      for (let y = s.first; y <= s.bottom + 1e-6; y += s.rowH) {
+        for (const x0 of pass) if (clear(x0, w, y)) return { text: candidate, x0, y, w, cut: candidate !== text };
+      }
+    }
+    return null;
+  };
+  const whole = attempt(text);
+  if (whole) return whole;
+  for (let k = text.length - 1; k >= 1; k--) {
+    const cut = attempt(ellipsize(text, k));
+    if (cut) return cut;
+  }
+  return null;
+}
+function placeYLabel(text, s) {
+  const above = s.py - s.gap;
+  const below = s.py + s.gap + s.textH;
+  const fitsRow = (y) => y - s.textH >= s.top - 1e-6 && y <= s.bottom + 1e-6;
+  const near = above - s.textH < s.top ? [below, above] : [above, below];
+  const rows = [...near, above - s.rowH, below + s.rowH].filter(fitsRow);
+  const clear = (x0, w, y) => x0 >= s.left + s.gap - 1e-6 && x0 + w <= s.right - s.gap + 1e-6 && !s.boxes.some((b) => x0 < b.x1 + s.gap && x0 + w + s.gap > b.x0 && y - s.textH < b.y1 && y > b.y0);
+  const attempt = (candidate) => {
+    const w = s.measure(candidate);
+    for (const y of rows) {
+      const inRow = s.boxes.filter((b) => y - s.textH < b.y1 && y > b.y0).map((b) => b.x0 - 2 * s.gap - w).sort((a, b) => b - a);
+      for (const x0 of [s.right - s.gap - w, ...inRow, s.left + s.gap]) if (clear(x0, w, y)) return { text: candidate, x0, y, w, cut: candidate !== text };
+    }
+    return null;
+  };
+  const whole = attempt(text);
+  if (whole) return whole;
+  for (let k = text.length - 1; k >= 1; k--) {
+    const cut = attempt(ellipsize(text, k));
+    if (cut) return cut;
+  }
+  return null;
+}
+
+export { CHART_ROLE, ChartDataTable, ChartSummary, DRAG_THRESHOLD, GROUP_MARGIN, KEY_PAN, KEY_ZOOM, MIN_SPAN_SHARE, NBSP, NOT_AVAILABLE, ResetZoomButton, SCIENTIFIC_BELOW, SHELL_TOKENS, Stage, ZOOM_HINT, allIntegers, applyTheme, axisTitleFits, bandsOf, barExtent, brushRange, brushWindow, categoryAt, chartSummary, clipExtent, countOverlaps, defaultChartName, firstVisible, fitLabel, fontFamily, formatNumber, formatTicks, formatTime, isZoomed, keyAction, leastLabelSpan, memberAt, memberSlots, niceStep, niceTicks, panRange, pick, pinchState, placeXLabel, placeYLabel, readTheme, referenceLineName, repeatedLabels, resolveToken, revealValue, roundWindow, sameData, stepIndex, stepWindow, textWidth, thinRows, unusedLegendTones, useFormat, useLangStore, useShellLang, useStageSize, useThemeStore, useThemeTokens, wheelFactor, widestLabel, windowRange, windowZoomed, wrapLines, zoomRange };