@weasel-js/ui-input 0.0.0-stage → 1.18.2

package/dist/index.js

@@ -0,0 +1,756 @@
+import { COARSE_STEPS, snapToStep } from '@weasel-js/quantity';
+export { COARSE_STEPS } from '@weasel-js/quantity';
+
+// src/heldAt.ts
+function heldAt(length, at) {
+  return at !== null && Number.isInteger(at) && at >= 0 && at < length ? at : null;
+}
+
+// src/tree.ts
+function treeKey(items, at, key, shape) {
+  const item = items[at];
+  if (item === void 0) return { handled: false };
+  const canToggle = shape.canToggle?.(item) ?? true;
+  const [opens, closes] = shape.dir === "rtl" ? ["ArrowLeft", "ArrowRight"] : ["ArrowRight", "ArrowLeft"];
+  if (key === opens) {
+    if (!shape.isBranch(item)) return { handled: false };
+    if (!shape.isOpen(item)) return canToggle ? { handled: true, toggle: at } : { handled: true, at: null };
+    const next = items[at + 1];
+    return { handled: true, at: next !== void 0 && shape.isChildOf(next, item) ? at + 1 : null };
+  }
+  if (key !== closes) return { handled: false };
+  if (shape.isOpen(item) && canToggle) return { handled: true, toggle: at };
+  const parent = items.findIndex((p) => shape.isChildOf(item, p));
+  return parent < 0 ? { handled: false } : { handled: true, at: parent };
+}
+
+// src/typeahead.ts
+var TYPEAHEAD_RESET_MS = 500;
+function isOneChar(text) {
+  return text.length > 0 && text.length <= 2 && [...text].length === 1;
+}
+var EMPTY_TYPEAHEAD = { text: "", at: -Infinity };
+function typeaheadMatch(items, at, query, shape) {
+  const q = fold(query);
+  const n = items.length;
+  const from = heldAt(n, at);
+  const start = from == null ? 0 : isOneChar(query) ? from + 1 : from;
+  for (let k = 0; k < n; k++) {
+    const i = (start + k) % n;
+    const item = items[i];
+    if ((shape.canStop?.(item) ?? true) && fold(shape.label(item)).startsWith(q)) return i;
+  }
+  return null;
+}
+function fold(s) {
+  return s.toLowerCase().normalize("NFC");
+}
+function typeaheadStep(items, from, buffer, key, now, shape, resetMs = TYPEAHEAD_RESET_MS) {
+  const prev = now - buffer.at < resetMs ? buffer.text : "";
+  const k = key.toLowerCase();
+  const cycling = prev !== "" && [...prev].every((c) => c.toLowerCase() === k);
+  const text = cycling ? key : prev + key;
+  return { buffer: { text, at: now }, hit: typeaheadMatch(items, from, text, shape) };
+}
+
+// src/list.ts
+var always = () => true;
+function firstStop(items, shape = {}) {
+  const i = items.findIndex(shape.canStop ?? always);
+  return i < 0 ? null : i;
+}
+function stepStop(items, at, dir, shape = {}) {
+  const canStop = shape.canStop ?? always;
+  const wrap = shape.wrap ?? true;
+  const n = items.length;
+  const from = heldAt(n, at);
+  let i = from ?? (dir === 1 ? -1 : n);
+  for (let k = 0; k < n; k++) {
+    i += dir;
+    if (i < 0 || i >= n) {
+      if (!wrap) break;
+      i = (i + n) % n;
+    }
+    if (canStop(items[i])) return i;
+  }
+  return !wrap && from !== null && canStop(items[from]) ? from : null;
+}
+function arrowDir(key, shape) {
+  const orientation = shape.orientation ?? "vertical";
+  if (orientation !== "horizontal") {
+    if (key === "ArrowDown") return 1;
+    if (key === "ArrowUp") return -1;
+  }
+  if (orientation !== "vertical") {
+    const forward = shape.dir === "rtl" ? -1 : 1;
+    if (key === "ArrowRight") return forward;
+    if (key === "ArrowLeft") return -forward;
+  }
+  return 0;
+}
+function rovingKey(items, at, key, shape = {}) {
+  if (key === "Home") return { handled: true, at: stepStop(items, null, 1, shape) };
+  if (key === "End") return { handled: true, at: stepStop(items, null, -1, shape) };
+  const dir = arrowDir(key, shape);
+  return dir === 0 ? { handled: false } : { handled: true, at: stepStop(items, at, dir, shape) };
+}
+function rowKey(items, at, press, shape = {}, searching = false, apple = false) {
+  const { key } = press;
+  const chord = !!(press.ctrlKey || press.metaKey);
+  const mod = !!(apple ? press.metaKey && !press.ctrlKey : press.ctrlKey && !press.metaKey);
+  if (shape.selectAll && key.toLowerCase() === "a" && mod && !press.altKey && !press.shiftKey) return { kind: "selectAll" };
+  const step = rovingKey(items, at, key, shape);
+  if (step.handled) return { kind: "move", at: step.at, extend: !!press.shiftKey };
+  if (shape.tree && (key === "ArrowRight" || key === "ArrowLeft")) {
+    const t = treeKey(items, at, key, shape.dir && !shape.tree.dir ? { ...shape.tree, dir: shape.dir } : shape.tree);
+    if (!t.handled) return null;
+    return "toggle" in t ? { kind: "toggle", at: t.toggle } : { kind: "move", at: t.at, extend: false };
+  }
+  if (key === " " && shape.typeahead && searching) return { kind: "type", held: true };
+  if (key === "Enter" || key === " ") return shape.activate ? { kind: "activate" } : null;
+  if (shape.typeahead && isOneChar(key) && !chord && !press.altKey) return { kind: "type", held: false };
+  return null;
+}
+
+// src/tabOrder.ts
+function tabSort(targets, declared) {
+  const key = (t) => declared(t) ?? Number.POSITIVE_INFINITY;
+  return [...targets].sort((a, b) => key(a) - key(b));
+}
+function tabStep(order, from, direction, isBefore) {
+  const forward = direction === "next";
+  const here = from === null ? -1 : order.indexOf(from);
+  let at;
+  if (here !== -1) at = here + (forward ? 1 : -1);
+  else if (from === null || !isBefore) at = forward ? 0 : order.length - 1;
+  else {
+    const after = order.findIndex((t) => isBefore(from, t));
+    const end = after === -1 ? order.length : after;
+    at = forward ? end : end - 1;
+  }
+  return order[at] ?? null;
+}
+function arrowSteps(key, shift, dir = "ltr") {
+  const steps = shift ? COARSE_STEPS : 1;
+  if (key === "ArrowUp") return steps;
+  if (key === "ArrowDown") return -steps;
+  const d = arrowDir(key, { orientation: "horizontal", dir });
+  return d === 0 ? null : d * steps;
+}
+function arrowMove(key, shift) {
+  const steps = arrowSteps(key, shift);
+  if (steps === null) return null;
+  return key === "ArrowRight" || key === "ArrowLeft" ? { dx: steps, dy: 0 } : { dx: 0, dy: -steps };
+}
+function rangeKey(key, shift, dir = "ltr") {
+  switch (key) {
+    case "PageUp":
+      return COARSE_STEPS;
+    case "PageDown":
+      return -COARSE_STEPS;
+    case "Home":
+      return "home";
+    case "End":
+      return "end";
+    default:
+      return arrowSteps(key, shift, dir);
+  }
+}
+
+// src/scalar.ts
+function clamp(v, lo, hi) {
+  const c = v > hi ? hi : v;
+  return c < lo ? lo : c;
+}
+function usableStops(stops, min, max) {
+  if (!stops || stops.length === 0) return [];
+  const byValue = /* @__PURE__ */ new Map();
+  for (const stop of stops) {
+    const s = typeof stop === "number" ? { value: stop } : stop;
+    if (!(s.value >= min && s.value <= max)) continue;
+    const seen = byValue.get(s.value);
+    if (!seen || seen.label === void 0 && s.label !== void 0) byValue.set(s.value, s);
+  }
+  return [...byValue.values()].sort((a, b) => a.value - b.value);
+}
+function attract(v, stops, tolerance, toFraction = (x) => x) {
+  const f = toFraction(v);
+  let best = v;
+  let bestGap = tolerance;
+  for (const stop of stops) {
+    const gap = Math.abs(toFraction(stop) - f);
+    if (gap <= bestGap) {
+      best = stop;
+      bestGap = gap;
+    }
+  }
+  return best;
+}
+function evenMap(stops) {
+  const gaps = stops.length - 1;
+  return {
+    toFraction(v) {
+      const x = clamp(v, stops[0], stops[gaps]);
+      let i = 0;
+      while (i < gaps - 1 && x > stops[i + 1]) i++;
+      return (i + (x - stops[i]) / (stops[i + 1] - stops[i])) / gaps;
+    },
+    toValue(f) {
+      const c = clamp(f, 0, 1);
+      const i = Math.min(gaps - 1, Math.floor(c * gaps));
+      return stops[i] + (c * gaps - i) * (stops[i + 1] - stops[i]);
+    }
+  };
+}
+function sliderAt(f, shape) {
+  const stops = shape.stops ?? [];
+  const v = shape.toValue(f);
+  if (shape.strict) return attract(v, stops, Infinity, shape.toFraction);
+  const q = clamp(snapToStep(v, shape.step, shape.origin ?? shape.min), shape.min, shape.max);
+  return stops.length > 0 && !shape.free ? attract(q, stops, shape.pull ?? 0, shape.toFraction) : q;
+}
+function stepStops(stops, v, direction, count) {
+  if (direction > 0) {
+    const first2 = stops.findIndex((stop) => stop > v);
+    if (first2 === -1) return stops[stops.length - 1];
+    return stops[Math.min(stops.length - 1, first2 + count - 1)];
+  }
+  let first = -1;
+  for (let i = stops.length - 1; i >= 0; i--) {
+    if (stops[i] < v) {
+      first = i;
+      break;
+    }
+  }
+  if (first === -1) return stops[0];
+  return stops[Math.max(0, first - (count - 1))];
+}
+function defaultStep(step, min, max) {
+  if (step !== void 0 && step > 0) return step;
+  return (max - min) / 100;
+}
+function clampOrdered(v, thumbs, index, min, max, step) {
+  const gap = step !== void 0 && step > 0 ? step : (max - min) / 1e3;
+  const below = index > 0 ? thumbs[index - 1].value : -Infinity;
+  const above = index < thumbs.length - 1 ? thumbs[index + 1].value : Infinity;
+  const lower = Math.max(min, below + gap);
+  const upper = Math.min(max, above - gap);
+  if (lower <= upper) return clamp(v, lower, upper);
+  const lo = Math.max(min, below);
+  const hi = Math.min(max, above);
+  return lo <= hi ? clamp(v, lo, hi) : clamp(v, min, max);
+}
+function crossEnd(from, delta, stepSize, range2, track) {
+  const [lo, hi] = range2;
+  if (from > hi) return delta < 0 ? Math.max(lo, hi + delta + stepSize) : from;
+  if (from < lo) return delta > 0 ? Math.min(hi, lo + delta - stepSize) : from;
+  if (from + delta > hi) return from < hi ? hi : track[1];
+  if (from + delta < lo) return from > lo ? lo : track[0];
+  return null;
+}
+function sliderKey(key, shift, shape) {
+  const move = rangeKey(key, shift, shape.dir);
+  if (move === null) return null;
+  const { thumbs, index, min, max, step } = shape;
+  const from = thumbs[index].value;
+  const [bLo, bHi] = shape.bounds?.() ?? [min, max];
+  const lo = Math.max(min, bLo);
+  const hi = Math.min(max, bHi);
+  const stops = shape.stops ?? [];
+  let v;
+  if (move === "home") v = lo;
+  else if (move === "end") v = hi;
+  else if (shape.keyStep) v = shape.keyStep(move);
+  else if (stops.length > 0) v = stepStops(stops, from, move > 0 ? 1 : -1, Math.abs(move));
+  else {
+    const range2 = shape.range ?? [min, max];
+    const stepSize = defaultStep(step, range2[0], range2[1]);
+    const delta = move * stepSize;
+    const crossed = crossEnd(from, delta, stepSize, range2, [min, max]);
+    if (crossed === null) v = snapToStep(from + delta, step, range2[0]);
+    else v = crossed > range2[0] && crossed < range2[1] ? snapToStep(crossed, step, range2[0]) : crossed;
+  }
+  v = clamp(v, lo, hi);
+  return shape.ordered ? clampOrdered(v, thumbs, index, lo, hi, step) : v;
+}
+
+// src/span.ts
+function spanPlace(span, v) {
+  const length = span.to - span.from;
+  return length === 0 ? 0 : (v - span.from) / length;
+}
+function spanValue(span, f) {
+  return span.from + f * (span.to - span.from);
+}
+function spanShare(span, length) {
+  const whole = span.to - span.from;
+  return whole === 0 ? 0 : length / whole;
+}
+function spanMap(span) {
+  return { toFraction: (v) => spanPlace(span, v), toValue: (f) => spanValue(span, f) };
+}
+function spanHold(span, bounds) {
+  if (span.from >= bounds.from && span.to <= bounds.to) return { from: span.from, to: span.to };
+  const length = Math.min(span.to - span.from, bounds.to - bounds.from);
+  let from = span.from;
+  if (from < bounds.from) from = bounds.from;
+  if (from + length > bounds.to) from = Math.max(bounds.from, bounds.to - length);
+  return { from, to: Math.min(bounds.to, from + length) };
+}
+function spanPan(span, by, bounds) {
+  return spanHold({ from: span.from + by, to: span.to + by }, bounds);
+}
+function spanZoom(span, at, factor, bounds, minLength = 0) {
+  const length = span.to - span.from;
+  const next = Math.min(bounds.to - bounds.from, Math.max(minLength, length * factor));
+  const f = length === 0 ? 0.5 : (at - span.from) / length;
+  return spanHold({ from: at - f * next, to: at + (1 - f) * next }, bounds);
+}
+
+// src/textCommit.ts
+function editEnd(cause, shape = {}) {
+  if (cause === "blur") return "commit";
+  if (cause.key === "Enter") return shape.multiline && cause.shift ? null : "commit";
+  if (cause.key === "Escape") return shape.escape ?? "cancel";
+  return null;
+}
+function imeKey(e) {
+  return e.isComposing === true || e.keyCode === 229 || e.key === "Process" || e.key === "Dead";
+}
+
+// src/reorder.ts
+var sortedSet = (at) => [...new Set(at.filter(Number.isInteger))].sort((a, b) => a - b);
+function moveItems(items, at, to) {
+  const inside = sortedSet(at).filter((i) => i >= 0 && i < items.length);
+  const gap = Math.min(items.length, Math.max(0, to));
+  const taken = new Set(inside);
+  const out = items.filter((_, i) => !taken.has(i));
+  out.splice(movedIndex(inside, gap), 0, ...inside.map((i) => items[i]));
+  return out;
+}
+function movedIndex(at, to) {
+  return to - sortedSet(at).filter((i) => i < to).length;
+}
+function isNoopDrop(at, to) {
+  const s = sortedSet(at);
+  if (s.length === 0) return false;
+  const first = s[0];
+  const last = s[s.length - 1];
+  return last - first + 1 === s.length && to >= first && to <= last + 1;
+}
+function nudgeGap(at, by, length) {
+  const s = sortedSet(at);
+  if (s.length === 0) return null;
+  const to = by < 0 ? s[0] - 1 : s[s.length - 1] + 2;
+  return to < 0 || to > length ? null : to;
+}
+function gapByMidpoint(mids, p) {
+  const backward = mids.length > 1 && mids[mids.length - 1] < mids[0];
+  return mids.filter((m) => backward ? m >= p : m <= p).length;
+}
+function nearestGap(gaps, p) {
+  let best = -1;
+  for (let k = 0; k < gaps.length; k++) if (best < 0 || Math.abs(gaps[k] - p) < Math.abs(gaps[best] - p)) best = k;
+  return best;
+}
+function dropBand(f, band = 0.5) {
+  if (f < band) return "before";
+  return f >= 1 - band ? "after" : "into";
+}
+function isNudgeChord(e) {
+  return e.altKey && !e.ctrlKey && !e.metaKey;
+}
+function nudgeOf(e, back = "ArrowUp", on = "ArrowDown") {
+  if (!isNudgeChord(e)) return null;
+  if (e.key === back) return -1;
+  return e.key === on ? 1 : null;
+}
+
+// src/edgeScroll.ts
+var EDGE_SCROLL_MARGIN = 48;
+function edgePush(span, p, margin = EDGE_SCROLL_MARGIN) {
+  if (!(margin > 0)) return 0;
+  const fromStart = p - span.from;
+  const fromEnd = span.to - p;
+  const towardStart = fromStart <= fromEnd;
+  const distance = towardStart ? fromStart : fromEnd;
+  if (distance >= margin) return 0;
+  const strength = Math.min(1, 1 - distance / margin);
+  return towardStart ? -strength : strength;
+}
+function edgeScroll(bounds, point, margin = EDGE_SCROLL_MARGIN) {
+  return {
+    x: edgePush({ from: bounds.x, to: bounds.x + bounds.width }, point.x, margin),
+    y: edgePush({ from: bounds.y, to: bounds.y + bounds.height }, point.y, margin)
+  };
+}
+
+// src/spatial.ts
+var HEADING_DRIFT = 2;
+function headingOf(key) {
+  if (key === "ArrowLeft") return "left";
+  if (key === "ArrowRight") return "right";
+  if (key === "ArrowUp") return "up";
+  return key === "ArrowDown" ? "down" : null;
+}
+function headingCost(from, to, heading, drift = HEADING_DRIFT) {
+  const dx = to.x + to.width / 2 - (from.x + from.width / 2);
+  const dy = to.y + to.height / 2 - (from.y + from.height / 2);
+  const across = heading === "left" || heading === "right";
+  const along = across ? dx : dy;
+  const ahead = heading === "left" || heading === "up" ? -along : along;
+  if (!(ahead > 0)) return null;
+  return ahead + drift * Math.abs(across ? dy : dx);
+}
+function nearestToward(from, targets, heading, drift = HEADING_DRIFT) {
+  let best = -1;
+  let bestCost = Infinity;
+  targets.forEach((to, i) => {
+    const cost = to ? headingCost(from, to, heading, drift) : null;
+    if (cost !== null && cost < bestCost) {
+      best = i;
+      bestCost = cost;
+    }
+  });
+  return best;
+}
+
+// src/scheduler.ts
+var timerScheduler = {
+  now: () => Date.now(),
+  set: (fn, ms2) => {
+    const t = setTimeout(fn, ms2);
+    return () => clearTimeout(t);
+  }
+};
+
+// src/stepRepeat.ts
+var REPEAT_DELAY_MS = 400;
+var REPEAT_EVERY_MS = 60;
+function createStepRepeat(step, spent, opts = {}) {
+  let cancel = null;
+  let key = null;
+  let hold = 0;
+  const stop = () => {
+    cancel?.();
+    cancel = null;
+    key = null;
+    hold++;
+  };
+  const stepThenWait = (k, ms2) => {
+    const mine = hold;
+    step(k);
+    if (hold !== mine) return;
+    cancel = (opts.scheduler ?? timerScheduler).set(() => {
+      if (spent(k)) return stop();
+      stepThenWait(k, opts.everyMs ?? REPEAT_EVERY_MS);
+    }, ms2);
+  };
+  return {
+    start(k) {
+      stop();
+      key = k;
+      stepThenWait(k, opts.delayMs ?? REPEAT_DELAY_MS);
+    },
+    stop,
+    held: () => key
+  };
+}
+
+// src/sweep.ts
+var SWEEP_CAP = 256;
+function stepsOf(sweep, cap = SWEEP_CAP) {
+  if (!(Number.isInteger(cap) && cap >= 0)) throw new RangeError(`a cap is a whole number of steps, not ${cap}`);
+  const steps = [];
+  for (const value of sweep.walk()) {
+    if (steps.length === cap) return { steps, capped: true };
+    steps.push(value);
+  }
+  return { steps, capped: false };
+}
+var clamp01 = (u) => u <= 0 ? 0 : u >= 1 ? 1 : u;
+var shown = (n) => +n.toPrecision(12);
+var tidy = (n, scale = 0) => {
+  const t = shown(n);
+  return Math.abs(t - n) <= 2 * Number.EPSILON * Math.max(Math.abs(n), Math.abs(scale)) ? t : n;
+};
+var plain = (n) => String(shown(n));
+function range(spec) {
+  const { from, to } = spec;
+  if (!Number.isFinite(from) || Number.isNaN(to)) throw new RangeError(`a range runs from a finite number to a number, not ${from} to ${to}`);
+  const span = to - from;
+  if (spec.step !== void 0) {
+    const step = spec.step;
+    if (!(step > 0)) throw new RangeError(`a range's step is above 0, not ${step}`);
+    const last = Number.isFinite(span) ? Math.floor(tidy(Math.abs(span) / step)) : Infinity;
+    const dir = span < 0 ? -1 : 1;
+    const nth = (i) => i === 0 ? from : tidy(from + dir * step * i, Math.max(Math.abs(from), step * i));
+    return {
+      at: (u) => {
+        if (!Number.isFinite(last)) throw new RangeError("an endless range has no point a fraction of the way along");
+        return nth(Math.round(clamp01(u) * last));
+      },
+      *walk() {
+        for (let i = 0; i <= last; i++) yield nth(i);
+      },
+      label: spec.label ?? plain
+    };
+  }
+  const count = spec.count;
+  if (!(Number.isInteger(count) && count > 0)) throw new RangeError(`a range's count is a whole number above 0, not ${count}`);
+  if (!Number.isFinite(span)) throw new RangeError("a range given a count needs a finite end");
+  const scale = Math.max(Math.abs(from), Math.abs(to));
+  const [lo, hi] = from <= to ? [from, to] : [to, from];
+  const along = (u) => u <= 0 ? from : u >= 1 ? to : Math.min(hi, Math.max(lo, tidy(from + span * u, scale)));
+  return {
+    at: (u) => along(clamp01(u)),
+    *walk() {
+      if (count === 1) yield from;
+      else for (let i = 0; i < count; i++) yield i === 0 ? from : i === count - 1 ? to : tidy(from + span * i / (count - 1), scale);
+    },
+    label: spec.label ?? plain
+  };
+}
+function values(list, label = String) {
+  if (list.length === 0) throw new RangeError("a sweep over values needs at least one");
+  return {
+    at: (u) => list[Math.round(clamp01(u) * (list.length - 1))],
+    walk: () => list,
+    label
+  };
+}
+var ms = (t) => `${shown(t)} ms`;
+function frames(span, options) {
+  const { every } = options;
+  if (!(every > 0)) throw new RangeError(`frames are a time above 0 apart, not ${every}`);
+  const duration = span.duration ?? Infinity;
+  if (!(duration >= 0)) throw new RangeError(`a run lasts 0 ms or more, not ${duration}`);
+  const loop = span.loop ?? false;
+  if (typeof loop === "number" && !(loop >= 0)) throw new RangeError(`a run loops 0 times or more, not ${loop}`);
+  const passes = loop === true ? Infinity : loop === false ? 1 : loop;
+  const walked = options.passes === "all" ? passes : 1;
+  const end = duration === 0 || walked === 0 ? 0 : duration * walked;
+  const ends = walked === passes && Number.isFinite(passes) && Number.isFinite(end);
+  const origin = span.origin ?? 0;
+  const label = options.label ?? ((t) => ms(origin + t));
+  return {
+    at: (u) => {
+      if (!Number.isFinite(end)) throw new RangeError("an endless run has no point a fraction of the way along");
+      return end * clamp01(u);
+    },
+    *walk() {
+      for (let i = 0; ; i++) {
+        const t = tidy(every * i);
+        if (t > end || t === end && !ends) break;
+        yield t;
+        if (t === end) return;
+      }
+      if (ends) yield end;
+    },
+    label
+  };
+}
+function until(sweep, done) {
+  return {
+    at: sweep.at,
+    *walk() {
+      let i = 0;
+      for (const value of sweep.walk()) {
+        if (done(value, i++)) return;
+        yield value;
+      }
+    },
+    label: sweep.label
+  };
+}
+
+// src/grid.ts
+function rowOffset(length, columns, align = "start") {
+  const gap = Math.max(0, columns - length);
+  return align === "center" ? gap / 2 : align === "end" ? gap : 0;
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var MAX_COLUMNS = 2 ** 24;
+var wholeColumns = (columns) => columns >= 1 ? Math.min(Math.floor(columns), MAX_COLUMNS) : 1;
+function tileGrid(count, spec) {
+  const columns = wholeColumns(spec.columns);
+  const lastRow = spec.lastRow ?? "start";
+  const short = count % columns;
+  const lastStart = count - (short || columns);
+  const filling = lastRow === "fill" && short > 0;
+  const tracks = filling ? columns * short / gcd(columns, short) : 2 * columns;
+  const span = tracks / columns;
+  const lead = short === 0 || lastRow === "fill" ? 0 : span * rowOffset(short, columns, lastRow);
+  const lastAtEnd = short === 0 || lastRow === "fill" || lastRow === "end";
+  return {
+    tracks,
+    span,
+    fillSpan: filling ? tracks / short : span,
+    lead,
+    lastStart,
+    stretched: (i) => filling && i >= lastStart,
+    corners: (i) => {
+      const at = [];
+      const single = count < columns;
+      if (i === 0 && (lead === 0 || !single)) at.push("ss");
+      if (i === Math.min(columns, count) - 1 && (lastAtEnd || !single)) at.push("se");
+      if (i === lastStart && lead === 0) at.push("es");
+      if (i === count - 1 && lastAtEnd) at.push("ee");
+      return at;
+    }
+  };
+}
+function tileRows(count, across) {
+  const columns = wholeColumns(across);
+  return Array.from({ length: Math.ceil(count / columns) }, (_, r) => Array.from({ length: Math.min(columns, count - r * columns) }, (_2, j) => r * columns + j));
+}
+function tileKey(current, key, count, spec, opts = {}) {
+  const rows = tileRows(count, spec.columns);
+  const enabled = opts.enabled ?? Array(count).fill(true);
+  return rovingGridTarget(current, key, enabled, rows, { dir: opts.dir, ...gridLayout(rows, spec.columns, spec.lastRow) });
+}
+function gridLayout(rows, across, lastRow = "start") {
+  const columns = wholeColumns(across);
+  const short = (row) => row.length < columns;
+  return {
+    offsets: rows.map((row) => short(row) ? rowOffset(row.length, columns, lastRow) : 0),
+    widths: rows.map((row) => short(row) && lastRow === "fill" ? columns / row.length : 1)
+  };
+}
+function itemUnder(row, at, lo, hi, down) {
+  let best = -1;
+  let most = 0;
+  for (let j = 0; j < row.length; j++) {
+    const start = at.offset + j * at.width;
+    const cover = Math.min(hi, start + at.width) - Math.max(lo, start);
+    if (cover > most + 1e-9 || down && cover > 0 && Math.abs(cover - most) <= 1e-9) {
+      best = j;
+      most = cover;
+    }
+  }
+  if (best >= 0) return row[best];
+  const nearest = Math.round(((lo + hi) / 2 - at.offset) / at.width - 0.5);
+  return row[Math.min(row.length - 1, Math.max(0, nearest))];
+}
+var isStop = (enabled) => enabled;
+function rovingGridTarget(current, key, enabled, rows, layout = {}) {
+  const step = key === "ArrowDown" ? 1 : key === "ArrowUp" ? -1 : 0;
+  if (step === 0) {
+    const moved = rovingKey(enabled, current, key, { canStop: isStop, orientation: "horizontal", dir: layout.dir });
+    return moved.handled ? moved.at : null;
+  }
+  const r = rows.findIndex((row) => row.includes(current));
+  if (r < 0) return null;
+  const at = (row) => ({ offset: layout.offsets?.[row] ?? 0, width: layout.widths?.[row] ?? 1 });
+  const here = at(r);
+  const lo = here.offset + rows[r].indexOf(current) * here.width;
+  for (let rr = r + step; rr >= 0 && rr < rows.length; rr += step) {
+    const i = itemUnder(rows[rr], at(rr), lo, lo + here.width, step > 0);
+    if (i !== void 0 && enabled[i]) return i;
+  }
+  return null;
+}
+
+// src/selection.ts
+var same = (a, b) => a === b || Number.isNaN(a) && Number.isNaN(b);
+function selection(spec, values2) {
+  const mixed = spec.mixedValues ?? [];
+  if (spec.mode === "multiple") {
+    const on = spec.value;
+    const flip = (list, v, to) => to ? [...list, v] : list.filter((w) => !same(w, v));
+    return {
+      mode: "multiple",
+      followsFocus: false,
+      stateOf: (i) => on.includes(values2[i]) ? "on" : mixed.includes(values2[i]) ? "mixed" : "off",
+      press: (i) => spec.onChange(flip(on, values2[i], !on.includes(values2[i]))),
+      edit: () => {
+        const initial = on;
+        let working = initial;
+        return {
+          set: (i, to) => {
+            const v = values2[i];
+            if (working.includes(v) === to) return;
+            const next = flip(working, v, to);
+            working = next;
+            spec.onChange(next);
+          },
+          revert: () => {
+            if (working !== initial) spec.onChange([...initial]);
+          }
+        };
+      }
+    };
+  }
+  const choose = (next) => spec.onChange(next);
+  return {
+    mode: "single",
+    followsFocus: spec.followsFocus ?? true,
+    stateOf: (i) => same(spec.value, values2[i]) ? "on" : mixed.includes(values2[i]) ? "mixed" : "off",
+    press: (i) => {
+      if (!same(spec.value, values2[i])) choose(values2[i]);
+      else if (spec.allowDeselect) choose(null);
+    },
+    edit: () => {
+      const initial = spec.value;
+      let working = initial;
+      return {
+        set: (i, to) => {
+          const next = to ? values2[i] : same(working, values2[i]) && spec.allowDeselect ? null : working;
+          if (same(next, working)) return;
+          working = next;
+          choose(next);
+        },
+        revert: () => {
+          if (!same(working, initial)) choose(initial);
+        }
+      };
+    }
+  };
+}
+function selectionOfEach(items) {
+  return {
+    mode: "multiple",
+    followsFocus: false,
+    stateOf: (i) => items[i].selected ? "on" : "off",
+    press: (i) => items[i].onChange(!items[i].selected),
+    edit: () => {
+      const initial = items.map((it) => it.selected);
+      const working = [...initial];
+      return {
+        set: (i, to) => {
+          if (working[i] === to) return;
+          working[i] = to;
+          items[i].onChange(to);
+        },
+        revert: () => {
+          working.forEach((to, i) => {
+            if (to === initial[i]) return;
+            working[i] = initial[i];
+            items[i].onChange(initial[i]);
+          });
+        }
+      };
+    }
+  };
+}
+function sweepFrom(model, from) {
+  const to = model.stateOf(from) !== "on";
+  const edit = model.edit();
+  return { reach: (i) => edit.set(i, to), revert: () => edit.revert() };
+}
+function selectionKeys(model, count, enabled = () => true) {
+  if (model.mode === "single" && model.followsFocus) {
+    let chosen = -1;
+    for (let i = 0; i < count && chosen < 0; i++) if (model.stateOf(i) === "on") chosen = i;
+    return { tabStop: chosen >= 0 ? chosen : void 0, landed: (i) => {
+      if (enabled(i)) model.edit().set(i, true);
+    } };
+  }
+  return { activate: (i) => {
+    if (enabled(i)) model.press(i);
+  } };
+}
+
+export { EDGE_SCROLL_MARGIN, EMPTY_TYPEAHEAD, HEADING_DRIFT, REPEAT_DELAY_MS, REPEAT_EVERY_MS, SWEEP_CAP, TYPEAHEAD_RESET_MS, arrowDir, arrowMove, arrowSteps, attract, clampOrdered, createStepRepeat, dropBand, edgePush, edgeScroll, editEnd, evenMap, firstStop, frames, gapByMidpoint, gridLayout, headingCost, headingOf, imeKey, isNoopDrop, isNudgeChord, isOneChar, moveItems, movedIndex, nearestGap, nearestToward, nudgeGap, nudgeOf, range, rangeKey, rovingGridTarget, rovingKey, rowKey, rowOffset, selection, selectionKeys, selectionOfEach, sliderAt, sliderKey, spanHold, spanMap, spanPan, spanPlace, spanShare, spanValue, spanZoom, stepStop, stepsOf, sweepFrom, tabSort, tabStep, tileGrid, tileKey, tileRows, timerScheduler, treeKey, typeaheadMatch, typeaheadStep, until, usableStops, values };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map