@bicharts/chart-host 0.6.83 → 0.6.85

package/dist/chunk-QIRLWJBI.mjs

@@ -0,0 +1,665 @@
+/*! @bicharts/chart-host — Apache-2.0. Bundled reference data: GeoNames (https://www.geonames.org/) CC BY 4.0; Natural Earth and US Census/TIGER (public domain). Full text: NOTICE in this package. */
+import {
+  DRAG_NOT_CLICK_PX,
+  gestureWasDrag,
+  isInsideControl,
+  rowIdxsFromMark
+} from "./chunk-IURROJT7.mjs";
+import {
+  AXIS_FILTER_CLASS,
+  CONTROL_CLASS,
+  LEGEND_MARK_CLASS,
+  MARK_CLASS,
+  ROW_IDX_ATTR,
+  SNAPSHOT_SVG_ATTR
+} from "./chunk-MR6TL7QZ.mjs";
+
+// src/lasso.ts
+var LASSO_ROW_CAP = 5e3;
+var LASSO_DRAG_PX = DRAG_NOT_CLICK_PX;
+var LASSO_SAMPLE_PX = 3;
+var LASSO_MAX_VERTICES = 400;
+var LASSO_RESTORE_MAX_VERTICES = 2e3;
+var LASSO_RESTORE_MAX_SHAPES = 32;
+var LASSO_EVENT = "llm-lasso";
+var LASSO_SURFACE_CLASS = "lch-lasso-surface";
+var LASSO_OUTLINE_CLASS = "lch-lasso-outline";
+var LASSO_COUNT_CLASS = "lch-lasso-count";
+var LASSO_NOTE_CLASS = "lch-lasso-note";
+var LASSO_PLOT_CLASS = "lch-plot";
+var LASSO_MODE_ATTR = "data-lch-lasso-mode";
+var LASSO_KNOB_KEY = "lasso";
+var LASSO_AXES_SLOT = "__lchLassoAxes";
+var LASSO_SLOT = "__lchLasso";
+var LASSO_DEFAULT_ACTIONS = Object.freeze(["select"]);
+var SVGNS = "http://www.w3.org/2000/svg";
+var MARKISH = `.${MARK_CLASS}[${ROW_IDX_ATTR}]:not([${ROW_IDX_ATTR}=""]), .${LEGEND_MARK_CLASS}, .${AXIS_FILTER_CLASS}`;
+var settingOf = (o) => o?.lasso;
+function lassoRowCap(setting) {
+  const n = Number(setting?.rowCap);
+  return Number.isFinite(n) && n >= 1 ? Math.floor(n) : LASSO_ROW_CAP;
+}
+function lassoActions(setting) {
+  const a = setting?.actions;
+  if (!Array.isArray(a)) return [...LASSO_DEFAULT_ACTIONS];
+  const out = [];
+  for (const n of a) if (typeof n === "string" && n.trim() && !out.includes(n.trim())) out.push(n.trim());
+  return out;
+}
+function lassoVerdict(setting, rows) {
+  if (!setting || setting.capable !== true) return "not-capable";
+  if (setting.enabled === false) return "disabled";
+  const n = Number(rows);
+  if (Number.isFinite(n) && n > lassoRowCap(setting)) return "over-cap";
+  return "on";
+}
+function makeShape(mode, pts) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of pts) {
+    if (p.x < minX) minX = p.x;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { mode, pts, minX, minY, maxX, maxY };
+}
+function rectCorners(a, b) {
+  return [{ x: a.x, y: a.y }, { x: b.x, y: a.y }, { x: b.x, y: b.y }, { x: a.x, y: b.y }];
+}
+function pointInShape(shape, x, y) {
+  const p = shape.pts;
+  if (p.length < 3) return false;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const q of p) {
+    if (q.x < minX) minX = q.x;
+    if (q.x > maxX) maxX = q.x;
+    if (q.y < minY) minY = q.y;
+    if (q.y > maxY) maxY = q.y;
+  }
+  if (x < minX || x > maxX || y < minY || y > maxY) return false;
+  if (shape.mode === "rect") return true;
+  let inside = false;
+  for (let i = 0, j = p.length - 1; i < p.length; j = i++) {
+    const xi = p[i].x, yi = p[i].y, xj = p[j].x, yj = p[j].y;
+    if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+  }
+  return inside;
+}
+function thin(pts, max) {
+  if (pts.length <= max) return pts;
+  const step = pts.length / max;
+  const out = [];
+  for (let i = 0; i < max; i++) out.push(pts[Math.floor(i * step)]);
+  out.push(pts[pts.length - 1]);
+  return out;
+}
+function frameOf(surface) {
+  const r = surface.getBoundingClientRect();
+  const num = (n) => {
+    const v = parseFloat(surface.getAttribute(n) || "0");
+    return Number.isFinite(v) ? v : 0;
+  };
+  return { left: r.left, top: r.top, width: r.width, height: r.height, sx: num("x"), sy: num("y"), sw: num("width"), sh: num("height") };
+}
+var frameUsable = (f) => f.width > 0 && f.height > 0;
+var insideFrame = (f, x, y) => frameUsable(f) && x >= f.left && x <= f.left + f.width && y >= f.top && y <= f.top + f.height;
+var toLocal = (f, p) => [
+  f.sx + (f.width > 0 ? (p.x - f.left) * f.sw / f.width : p.x - f.left),
+  f.sy + (f.height > 0 ? (p.y - f.top) * f.sh / f.height : p.y - f.top)
+];
+var fromLocal = (f, p) => ({
+  x: f.left + (f.sw > 0 ? (p[0] - f.sx) * f.width / f.sw : p[0] - f.sx),
+  y: f.top + (f.sh > 0 ? (p[1] - f.sy) * f.height / f.sh : p[1] - f.sy)
+});
+var finiteNumber = (v) => {
+  const n = v instanceof Date ? +v : typeof v === "number" ? v : NaN;
+  return Number.isFinite(n) ? n : NaN;
+};
+var finitePair = (v) => {
+  if (!v || typeof v !== "object") return null;
+  const a = finiteNumber(v[0]), b = finiteNumber(v[1]);
+  return Number.isFinite(a) && Number.isFinite(b) ? [a, b] : null;
+};
+function axesOf(container) {
+  const a = container[LASSO_AXES_SLOT];
+  return a && typeof a.toData === "function" && typeof a.toScreen === "function" ? a : null;
+}
+function toStored(shapes, f, axes) {
+  if (axes) {
+    try {
+      const out = [];
+      for (const s of shapes) {
+        const pts = [];
+        for (const p of s.pts) {
+          const d = finitePair(axes.toData(toLocal(f, p)));
+          if (!d) throw new Error("no data coordinate");
+          pts.push(d);
+        }
+        out.push({ mode: s.mode, pts });
+      }
+      return { v: 1, space: "data", shapes: out };
+    } catch {
+    }
+  }
+  const w = f.width > 0 ? f.width : 1, h = f.height > 0 ? f.height : 1;
+  return {
+    v: 1,
+    space: "unit",
+    shapes: shapes.map((s) => ({ mode: s.mode, pts: s.pts.map((p) => [(p.x - f.left) / w, (p.y - f.top) / h]) }))
+  };
+}
+function fromStored(raw, f, axes) {
+  try {
+    if (!raw || typeof raw !== "object") return [];
+    const o = raw;
+    const space = o.space === "data" ? "data" : o.space === "unit" ? "unit" : null;
+    if (!space || !Array.isArray(o.shapes) || o.shapes.length === 0 || o.shapes.length > LASSO_RESTORE_MAX_SHAPES) return [];
+    if (space === "data" && !axes) return [];
+    if (!frameUsable(f)) return [];
+    const out = [];
+    for (const s of o.shapes) {
+      if (!s || typeof s !== "object" || !Array.isArray(s.pts)) return [];
+      const mode = s.mode === "rect" ? "rect" : "free";
+      if (s.pts.length < 3 || s.pts.length > LASSO_RESTORE_MAX_VERTICES) return [];
+      if (mode === "rect" && s.pts.length !== 4) return [];
+      const pts = [];
+      for (const v of s.pts) {
+        const p = finitePair(v);
+        if (!p) return [];
+        if (space === "unit") {
+          pts.push({ x: f.left + p[0] * f.width, y: f.top + p[1] * f.height });
+        } else {
+          const scr = finitePair(axes.toScreen(p));
+          if (!scr) return [];
+          pts.push(fromLocal(f, scr));
+        }
+      }
+      const shape = makeShape(mode, pts);
+      const outside = shape.maxX < f.left || shape.minX > f.left + f.width || shape.maxY < f.top || shape.minY > f.top + f.height;
+      if (!outside) out.push(shape);
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function gatherCentres(container) {
+  const out = [];
+  for (const el of Array.from(container.querySelectorAll(`.${MARK_CLASS}[${ROW_IDX_ATTR}]`))) {
+    const rows = rowIdxsFromMark(el);
+    if (!rows.length) continue;
+    const r = el.getBoundingClientRect();
+    if (!(r.width > 0 || r.height > 0)) continue;
+    out.push({ x: r.left + r.width / 2, y: r.top + r.height / 2, el, rows });
+  }
+  return out;
+}
+function markHidden(el, win) {
+  try {
+    const cs = win?.getComputedStyle?.(el);
+    return !!cs && (cs.visibility === "hidden" || cs.display === "none");
+  } catch {
+    return false;
+  }
+}
+function rowsInside(centres, shapes, win, skipHidden = true) {
+  const set = /* @__PURE__ */ new Set();
+  for (const c of centres) {
+    if (!shapes.some((s) => pointInShape(s, c.x, c.y))) continue;
+    if (skipHidden && markHidden(c.el, win)) continue;
+    for (const r of c.rows) set.add(r);
+  }
+  return Array.from(set).sort((a, b) => a - b);
+}
+var sameRows = (a, b) => a.length === b.length && a.every((r, i) => r === b[i]);
+var ACTIONS = /* @__PURE__ */ new Map([
+  // The host's own selection: the same publish a mark click makes, so the dim and the subscribers follow.
+  ["select", (ctx) => ctx.env.select(ctx.rows)]
+]);
+function registerLassoAction(name, action) {
+  if (typeof name === "string" && name && typeof action === "function") ACTIONS.set(name, action);
+}
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function readStored(options, container) {
+  const ui = options?.uiState;
+  const knobs = isObject(ui) ? ui.knobs : void 0;
+  if (isObject(knobs) && knobs[LASSO_KNOB_KEY] !== void 0) return knobs[LASSO_KNOB_KEY];
+  const bag = container.__lchKnobs;
+  return isObject(bag) ? bag[LASSO_KNOB_KEY] : void 0;
+}
+function writeStored(container, options, value) {
+  const holder = container;
+  if (!isObject(holder.__lchKnobs)) holder.__lchKnobs = {};
+  const bag = holder.__lchKnobs;
+  const had = bag[LASSO_KNOB_KEY] !== void 0 || readStored(options, container) !== void 0;
+  if (value === null && !had) return;
+  if (value === null) delete bag[LASSO_KNOB_KEY];
+  else bag[LASSO_KNOB_KEY] = value;
+  if (typeof options.setUiState !== "function") return;
+  const ui = isObject(options.uiState) ? options.uiState : {};
+  const live = holder.__lchUiLiveOpts === options && holder.__lchUiLiveSeed === options.uiState ? holder.__lchUiLive : null;
+  const base = isObject(live) ? live : ui;
+  const next = { ...base };
+  const knobs = { ...isObject(base.knobs) ? base.knobs : {}, ...bag };
+  if (value === null) delete knobs[LASSO_KNOB_KEY];
+  next.knobs = knobs;
+  holder.__lchUiLive = next;
+  holder.__lchUiLiveOpts = options;
+  holder.__lchUiLiveSeed = options.uiState;
+  try {
+    options.setUiState(next);
+  } catch {
+  }
+}
+function svgBox(svg) {
+  const vb = (svg.getAttribute("viewBox") || "").trim().split(/[\s,]+/).map(Number);
+  if (vb.length === 4 && vb.every(Number.isFinite) && vb[2] > 0 && vb[3] > 0) return { x: vb[0], y: vb[1], w: vb[2], h: vb[3] };
+  const r = svg.getBoundingClientRect();
+  if (r.width > 0 && r.height > 0) return { x: 0, y: 0, w: r.width, h: r.height };
+  const w = parseFloat(svg.getAttribute("width") || ""), h = parseFloat(svg.getAttribute("height") || "");
+  return w > 0 && h > 0 ? { x: 0, y: 0, w, h } : null;
+}
+function findPlot(container) {
+  const grouped = container.querySelector(`.${LASSO_PLOT_CLASS}`);
+  const tag = grouped?.tagName?.toLowerCase();
+  if (grouped && grouped.namespaceURI === SVGNS && (tag === "g" || tag === "svg")) {
+    if (tag === "svg") {
+      const b3 = svgBox(grouped);
+      return b3 ? { host: grouped, box: b3 } : null;
+    }
+    try {
+      const b3 = grouped.getBBox?.();
+      if (b3 && b3.width > 0 && b3.height > 0) return { host: grouped, box: { x: b3.x, y: b3.y, w: b3.width, h: b3.height } };
+    } catch {
+    }
+    const svg2 = grouped.ownerSVGElement ?? grouped.closest("svg");
+    const b2 = svg2 ? svgBox(svg2) : null;
+    return b2 ? { host: grouped, box: b2 } : null;
+  }
+  const svg = container.querySelector(`svg[${SNAPSHOT_SVG_ATTR}]`) ?? container.querySelector("svg");
+  const b = svg ? svgBox(svg) : null;
+  return svg && b ? { host: svg, box: b } : null;
+}
+function fmtCount(n, culture) {
+  try {
+    return new Intl.NumberFormat(culture || void 0).format(n);
+  } catch {
+    return String(n);
+  }
+}
+function showNote(env, rows, cap) {
+  const { container } = env;
+  const doc = container.ownerDocument;
+  const win = doc.defaultView;
+  const opts = env.options();
+  const note = doc.createElement("div");
+  note.className = LASSO_NOTE_CLASS;
+  note.setAttribute("role", "note");
+  note.textContent = `Lasso selection is off at ${fmtCount(rows, opts?.cultureCode)} rows (limit ${fmtCount(cap, opts?.cultureCode)})`;
+  Object.assign(note.style, {
+    position: "absolute",
+    right: "6px",
+    bottom: "2px",
+    font: "11px/1.2 system-ui, sans-serif",
+    opacity: "0.75",
+    pointerEvents: "none",
+    whiteSpace: "nowrap",
+    zIndex: "2",
+    color: opts?.themeFg || "inherit"
+  });
+  try {
+    if (win?.getComputedStyle(container).position === "static") container.style.position = "relative";
+  } catch {
+  }
+  container.appendChild(note);
+  const handle = {
+    surface: null,
+    rows: () => [],
+    clear: () => {
+    },
+    destroy: () => {
+      note.remove();
+      if (container[LASSO_SLOT] === handle) container[LASSO_SLOT] = null;
+    }
+  };
+  container[LASSO_SLOT] = handle;
+  return handle;
+}
+function installLasso(env) {
+  const { container } = env;
+  const doc = container.ownerDocument;
+  const win = doc.defaultView ?? globalThis;
+  const holder = container;
+  try {
+    holder[LASSO_SLOT]?.destroy();
+  } catch {
+  }
+  holder[LASSO_SLOT] = null;
+  const setting = settingOf(env.options());
+  const verdict = lassoVerdict(setting, env.rows);
+  if (verdict === "not-capable" || verdict === "disabled") return null;
+  if (verdict === "over-cap") return showNote(env, env.rows, lassoRowCap(setting));
+  const plot = findPlot(container);
+  if (!plot) return null;
+  const surface = doc.createElementNS(SVGNS, "rect");
+  surface.setAttribute("class", `${CONTROL_CLASS} ${LASSO_SURFACE_CLASS}`);
+  surface.setAttribute("x", String(plot.box.x));
+  surface.setAttribute("y", String(plot.box.y));
+  surface.setAttribute("width", String(plot.box.w));
+  surface.setAttribute("height", String(plot.box.h));
+  surface.setAttribute("fill", "transparent");
+  surface.setAttribute("pointer-events", "all");
+  surface.setAttribute("tabindex", "0");
+  surface.setAttribute("aria-label", "Selection area: drag to draw around marks, Escape to clear");
+  Object.assign(surface.style, { cursor: "crosshair", touchAction: "none", userSelect: "none" });
+  plot.host.insertBefore(surface, plot.host.firstChild);
+  const outline = doc.createElementNS(SVGNS, "path");
+  outline.setAttribute("class", LASSO_OUTLINE_CLASS);
+  outline.setAttribute("pointer-events", "none");
+  outline.setAttribute("fill-opacity", "0.12");
+  outline.setAttribute("stroke-width", "1.5");
+  outline.setAttribute("stroke-dasharray", "5 3");
+  outline.setAttribute("d", "");
+  const count = doc.createElementNS(SVGNS, "text");
+  count.setAttribute("class", LASSO_COUNT_CLASS);
+  count.setAttribute("pointer-events", "none");
+  count.setAttribute("font-size", "12");
+  count.setAttribute("x", String(plot.box.x + 6));
+  count.setAttribute("y", String(plot.box.y + 16));
+  Object.assign(count.style, { userSelect: "none" });
+  plot.host.appendChild(outline);
+  plot.host.appendChild(count);
+  const paintInk = () => {
+    const o = env.options();
+    const fg = o?.themeFg || "currentColor";
+    outline.setAttribute("stroke", fg);
+    outline.setAttribute("fill", o?.themeAccent || fg);
+    count.setAttribute("fill", fg);
+  };
+  paintInk();
+  let shapes = [];
+  let rowsNow = [];
+  let gesture = null;
+  let press = null;
+  let tail = false;
+  let centres = [];
+  const frame = () => frameOf(surface);
+  const modeNow = () => container.getAttribute(LASSO_MODE_ATTR) === "rect" ? "rect" : "free";
+  const dFor = (list, f) => list.map((s) => {
+    const loc = s.pts.map((p) => toLocal(f, p));
+    return "M" + loc.map((p) => `${round(p[0])} ${round(p[1])}`).join("L") + "Z";
+  }).join("");
+  const round = (n) => Math.round(n * 100) / 100;
+  const drawRest = () => {
+    outline.setAttribute("d", shapes.length ? dFor(shapes, frame()) : "");
+  };
+  const setCount = (n) => {
+    count.textContent = n === null ? "" : `${fmtCount(n, env.options()?.cultureCode)} selected`;
+  };
+  const detail = (rows, list, source) => {
+    const stored = toStored(list, frame(), axesOf(container));
+    const last = stored.shapes[stored.shapes.length - 1];
+    return {
+      rows,
+      polygon: last ? last.pts : [],
+      polygons: stored.shapes.map((s) => s.pts),
+      mode: last ? last.mode : modeNow(),
+      space: stored.space,
+      source
+    };
+  };
+  const emit = (d) => {
+    const Ev = win.CustomEvent ?? globalThis.CustomEvent;
+    try {
+      container.dispatchEvent(new Ev(LASSO_EVENT, { detail: d, bubbles: true }));
+    } catch {
+    }
+  };
+  const persist = (list) => {
+    try {
+      writeStored(container, env.options(), list ? toStored(list, frame(), axesOf(container)) : null);
+    } catch {
+    }
+  };
+  const commit = (list, rows) => {
+    shapes = list;
+    rowsNow = rows;
+    drawRest();
+    setCount(null);
+    persist(list);
+    const ctx = { rows: rows.slice(), mode: list[list.length - 1].mode, source: "user", env };
+    for (const name of lassoActions(settingOf(env.options()))) {
+      const run = ACTIONS.get(name);
+      if (!run) continue;
+      try {
+        run(ctx);
+      } catch {
+      }
+    }
+    emit(detail(rows, list, "user"));
+  };
+  const clear = (opts = {}) => {
+    const had = shapes.length > 0;
+    if (gesture) endGesture();
+    shapes = [];
+    rowsNow = [];
+    drawRest();
+    setCount(null);
+    if (opts.publish !== false) {
+      try {
+        env.clearSelection();
+      } catch {
+      }
+    }
+    if (had) {
+      persist(null);
+      emit(detail([], [], opts.source ?? "user"));
+    }
+  };
+  const beginsOffMark = (target, x, y) => {
+    const t = target;
+    if (!t || t.nodeType !== 1) return false;
+    if (t !== surface) {
+      if (!plot.host.contains(t)) return false;
+      if (t.closest?.(MARKISH)) return false;
+      if (isInsideControl(t, container)) return false;
+    }
+    try {
+      const stack = doc.elementsFromPoint?.(x, y);
+      if (stack) {
+        for (const el of stack) if (el !== surface && container.contains(el) && el.closest?.(MARKISH)) return false;
+      }
+    } catch {
+    }
+    return true;
+  };
+  const stopSelect = (e) => e.preventDefault();
+  const listen = (on) => {
+    const m = on ? "addEventListener" : "removeEventListener";
+    doc[m]("pointermove", onMove);
+    doc[m]("pointerup", onUp);
+    doc[m]("pointercancel", onCancel);
+    doc[m]("selectstart", stopSelect);
+  };
+  const endGesture = () => {
+    if (!gesture) return;
+    const wasDragging = gesture.dragging;
+    gesture = null;
+    listen(false);
+    centres = [];
+    setCount(null);
+    if (wasDragging) {
+      tail = true;
+      drawRest();
+    }
+  };
+  const liveShape = (g) => g.mode === "rect" ? makeShape("rect", rectCorners(g.start, g.end)) : makeShape("free", [...g.pts, g.end]);
+  const paintLive = (g) => {
+    const f = frame();
+    const live = liveShape(g);
+    const parts = g.additive ? [...shapes, live] : [live];
+    outline.setAttribute("d", dFor(parts, f));
+    setCount(rowsInside(centres, parts, win, false).length);
+  };
+  function onDown(e) {
+    tail = false;
+    const x = Number(e.clientX), y = Number(e.clientY);
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+    press = { x, y };
+    if (gesture || e.button != null && e.button !== 0 || e.isPrimary === false) return;
+    const f = frame();
+    if (!insideFrame(f, x, y) || !beginsOffMark(e.target, x, y)) return;
+    gesture = {
+      id: e.pointerId,
+      start: { x, y },
+      pts: [{ x, y }],
+      end: { x, y },
+      additive: !!(e.ctrlKey || e.metaKey || e.shiftKey),
+      mode: modeNow(),
+      dragging: false
+    };
+    try {
+      if (e.pointerId != null && typeof surface.setPointerCapture === "function") surface.setPointerCapture(e.pointerId);
+    } catch {
+    }
+    listen(true);
+  }
+  function onMove(e) {
+    const g = gesture;
+    if (!g || g.id != null && e.pointerId != null && e.pointerId !== g.id) return;
+    const p = { x: Number(e.clientX), y: Number(e.clientY) };
+    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) return;
+    if (!g.dragging) {
+      if (!gestureWasDrag(g.start, p, LASSO_DRAG_PX)) return;
+      g.dragging = true;
+      centres = gatherCentres(container);
+      paintInk();
+    }
+    g.end = p;
+    if (g.mode === "free") {
+      const last = g.pts[g.pts.length - 1];
+      if (Math.hypot(p.x - last.x, p.y - last.y) >= LASSO_SAMPLE_PX) g.pts.push(p);
+    }
+    paintLive(g);
+  }
+  function onUp(e) {
+    const g = gesture;
+    if (!g || g.id != null && e.pointerId != null && e.pointerId !== g.id) return;
+    if (!g.dragging) {
+      endGesture();
+      return;
+    }
+    const x = Number(e.clientX), y = Number(e.clientY);
+    if (Number.isFinite(x) && Number.isFinite(y)) g.end = { x, y };
+    const additive = g.additive;
+    const mode = g.mode;
+    let pts = mode === "rect" ? rectCorners(g.start, g.end) : [...g.pts, g.end];
+    endGesture();
+    if (mode === "free") {
+      if (pts.length < 3) return;
+      pts = thin(pts, LASSO_MAX_VERTICES);
+    }
+    const shape = makeShape(mode, pts);
+    const fresh = gatherCentres(container);
+    const added = rowsInside(fresh, [shape], win);
+    if (!added.length) return;
+    const list = additive ? [...shapes, shape] : [shape];
+    const rows = additive ? rowsInside(fresh, list, win) : added;
+    if (additive && sameRows(rows, rowsNow)) return;
+    commit(list, rows);
+    try {
+      surface.focus?.({ preventScroll: true });
+    } catch {
+    }
+  }
+  function onCancel(e) {
+    const g = gesture;
+    if (!g || g.id != null && e.pointerId != null && e.pointerId !== g.id) return;
+    endGesture();
+  }
+  function onClick(e) {
+    const wasDrag = tail || Number(e.detail) > 0 && !!press && gestureWasDrag(press, { x: Number(e.clientX), y: Number(e.clientY) }, LASSO_DRAG_PX);
+    tail = false;
+    press = null;
+    if (e.target !== surface || wasDrag) return;
+    if (e.ctrlKey || e.metaKey || e.shiftKey) return;
+    clear({ publish: true, source: "user" });
+  }
+  function onKey(e) {
+    if (e.key !== "Escape" || e.defaultPrevented) return;
+    if (gesture) {
+      endGesture();
+      e.preventDefault?.();
+      return;
+    }
+    if (shapes.length) {
+      clear({ publish: true, source: "user" });
+      e.preventDefault?.();
+    }
+  }
+  container.addEventListener("pointerdown", onDown, true);
+  container.addEventListener("click", onClick, true);
+  container.addEventListener("keydown", onKey);
+  const handle = {
+    surface,
+    rows: () => rowsNow.slice(),
+    clear,
+    destroy() {
+      if (gesture) {
+        gesture = null;
+        listen(false);
+      }
+      container.removeEventListener("pointerdown", onDown, true);
+      container.removeEventListener("click", onClick, true);
+      container.removeEventListener("keydown", onKey);
+      surface.remove();
+      outline.remove();
+      count.remove();
+      if (holder[LASSO_SLOT] === handle) holder[LASSO_SLOT] = null;
+    }
+  };
+  holder[LASSO_SLOT] = handle;
+  const restored = fromStored(readStored(env.options(), container), frame(), axesOf(container));
+  if (restored.length) {
+    const rows = rowsInside(gatherCentres(container), restored, win);
+    if (rows.length) {
+      shapes = restored;
+      rowsNow = rows;
+      drawRest();
+      emit(detail(rows, restored, "restore"));
+    }
+  }
+  return handle;
+}
+function clearLasso(container, opts) {
+  try {
+    container?.[LASSO_SLOT]?.clear(opts);
+  } catch {
+  }
+}
+
+export {
+  LASSO_ROW_CAP,
+  LASSO_DRAG_PX,
+  LASSO_SAMPLE_PX,
+  LASSO_MAX_VERTICES,
+  LASSO_RESTORE_MAX_VERTICES,
+  LASSO_RESTORE_MAX_SHAPES,
+  LASSO_EVENT,
+  LASSO_SURFACE_CLASS,
+  LASSO_OUTLINE_CLASS,
+  LASSO_COUNT_CLASS,
+  LASSO_NOTE_CLASS,
+  LASSO_PLOT_CLASS,
+  LASSO_MODE_ATTR,
+  LASSO_KNOB_KEY,
+  LASSO_AXES_SLOT,
+  LASSO_DEFAULT_ACTIONS,
+  lassoRowCap,
+  lassoActions,
+  lassoVerdict,
+  pointInShape,
+  registerLassoAction,
+  installLasso,
+  clearLasso
+};