@smwb/ui-solid 0.12.1 → 0.14.0

package/dist/headless/components/layout/tabGroups/tabGroupsLayout.js

@@ -0,0 +1,480 @@
+const gt = 1, nt = {
+  top: "above",
+  right: "on the right",
+  bottom: "below",
+  left: "on the left"
+}, rt = {
+  group: (t, n) => n === 1 ? "Tabs" : `Group ${t} of ${n}`,
+  groupActions: "Group actions",
+  splitRight: "Split right",
+  splitDown: "Split down",
+  moveToPreviousGroup: "Move to previous group",
+  moveToNextGroup: "Move to next group",
+  moveLeft: "Move tab left",
+  moveRight: "Move tab right",
+  resize: "Resize groups",
+  movedToGroup: (t, n, r) => `${t} moved to group ${n} of ${r}`,
+  movedToNewGroup: (t, n) => `${t} moved to a new group ${nt[n]}`,
+  movedInGroup: (t, n, r) => `${t} moved to position ${n} of ${r}`
+}, x = 0.05, P = 1e-6, k = x * 2, et = 32, it = 1e-6;
+function d(t, n) {
+  const r = t[n];
+  if (r === void 0) throw new RangeError(`tabGroupsLayout: no item at ${n}`);
+  return r;
+}
+function z(t, n, r) {
+  return Math.min(r, Math.max(n, t));
+}
+function st(t) {
+  return Math.round(t * 1e4) / 1e4;
+}
+function b(t) {
+  return t.reduce((n, r) => n + r, 0);
+}
+function R(t, n) {
+  return t.type === "group" ? n.push(t) : t.children.forEach((r) => R(r, n)), n;
+}
+function N(t) {
+  return t.type === "group" ? t : N(d(t.children, 0));
+}
+function j(t) {
+  return t.type === "group" ? t : j(d(t.children, t.children.length - 1));
+}
+function L(t, n) {
+  n(t), t.type === "split" && t.children.forEach((r) => L(r, n));
+}
+function G(t, n, r = []) {
+  if (t.id === n) return r;
+  if (t.type !== "group")
+    for (let e = 0; e < t.children.length; e++) {
+      const i = G(d(t.children, e), n, [...r, e]);
+      if (i) return i;
+    }
+}
+function T(t, n) {
+  let r = t;
+  for (const e of n) r = d(r.children, e);
+  return r;
+}
+function m(t, n, r) {
+  if (n.length === 0) return r;
+  const e = t, [i, ...s] = n, o = e.children.slice();
+  return o[i] = m(d(o, i), s, r), { ...e, children: o };
+}
+function S(t, n) {
+  return _(t).find((r) => r.id === n);
+}
+function F(t, n) {
+  const r = G(t, n.id);
+  return r ? m(t, r, n) : t;
+}
+function A(t, n, r = t.activeGroup) {
+  return n === t.root && r === t.activeGroup ? t : { version: 1, root: n, activeGroup: r };
+}
+function H(t, n, r) {
+  const e = (s) => s !== void 0 && R(n, []).some((o) => o.id === s);
+  if (e(r)) return r;
+  const i = vt(t, r);
+  return i !== void 0 && e(i) ? i : N(n).id;
+}
+function C(t, n) {
+  let r = 0;
+  return L(t, (e) => {
+    const i = /^(\D+)(\d+)$/.exec(e.id);
+    i && i[1] === n && (r = Math.max(r, Number(i[2])));
+  }), `${n}${r + 1}`;
+}
+function w(t) {
+  if (t.type === "group") return t;
+  let n = !1;
+  const r = [];
+  let e = [];
+  if (t.children.forEach((s, o) => {
+    const c = t.sizes[o] ?? 0, u = w(s);
+    u !== s && (n = !0), u.type === "split" && u.direction === t.direction ? (n = !0, u.children.forEach((f, l) => {
+      r.push(f), e.push(c * (u.sizes[l] ?? 0) / 100);
+    })) : (r.push(u), e.push(c));
+  }), r.length === 1) return d(r, 0);
+  const i = b(e);
+  return i > 0 && Math.abs(i - 100) > P && (n = !0, e = e.map((s) => s * 100 / i)), n ? { ...t, children: r, sizes: e } : t;
+}
+function ot(t, n) {
+  const r = n.slice(0, -1), e = d(n, n.length - 1), i = T(t, r), s = e > 0 ? e - 1 : e + 1, o = i.sizes.slice();
+  o[s] = (o[s] ?? 0) + (o[e] ?? 0), o.splice(e, 1);
+  const c = i.children.filter((u, f) => f !== e);
+  return w(m(t, r, { ...i, children: c, sizes: o }));
+}
+function U(t, n, r) {
+  const e = G(t, n.id), i = n.tabs.indexOf(r), s = n.tabs.filter((c) => c !== r);
+  if (s.length === 0 && e.length > 0) return { root: ot(t, e), closed: !0 };
+  const o = n.active === r ? s[i] ?? s[i - 1] ?? null : n.active;
+  return { root: m(t, e, { ...n, tabs: s, active: o }), closed: !1 };
+}
+function ct(t, n, r, e, i) {
+  const s = G(t, n), o = T(t, s), c = o.tabs.slice();
+  c.splice(z(e ?? c.length, 0, c.length), 0, r);
+  const u = i || o.active === null ? r : o.active;
+  return m(t, s, { ...o, tabs: c, active: u });
+}
+function ut(t, n, r, e, i) {
+  const s = G(t, n), o = e === "left" || e === "right" ? "row" : "column", c = e === "left" || e === "top";
+  if (s.length > 0) {
+    const l = s.slice(0, -1), p = d(s, s.length - 1), a = T(t, l);
+    if (a.direction === o) {
+      const h = (a.sizes[p] ?? 0) / 2, v = a.children.slice(), g = a.sizes.slice();
+      g[p] = h;
+      const E = c ? p : p + 1;
+      return v.splice(E, 0, r), g.splice(E, 0, h), m(t, l, { ...a, children: v, sizes: g });
+    }
+  }
+  const u = T(t, s);
+  return m(t, s, {
+    type: "split",
+    id: i,
+    direction: o,
+    children: c ? [r, u] : [u, r],
+    sizes: [50, 50]
+  });
+}
+function xt(t = [], n = {}) {
+  const r = Array.from(new Set(t)), e = n.active !== void 0 && r.includes(n.active) ? n.active : r[0] ?? null;
+  return {
+    version: 1,
+    root: { type: "group", id: "g1", tabs: r, active: e },
+    activeGroup: "g1"
+  };
+}
+function I(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function X(t, n, r = 0) {
+  if (!I(t) || r > et) return null;
+  const e = typeof t.id == "string" ? t.id : "";
+  if (t.type === "group") {
+    const p = [];
+    if (Array.isArray(t.tabs))
+      for (const h of t.tabs)
+        typeof h != "string" || n.has(h) || (n.add(h), p.push(h));
+    const a = typeof t.active == "string" && p.includes(t.active) ? t.active : p[0] ?? null;
+    return { type: "group", id: e, tabs: p, active: a };
+  }
+  const i = t.direction;
+  if (t.type !== "split" || i !== "row" && i !== "column" || !Array.isArray(t.children))
+    return null;
+  const s = t.children, o = t.sizes, c = Array.isArray(o) && o.length === s.length && o.every((p) => typeof p == "number" && Number.isFinite(p) && p > 0), u = c && !Number.isFinite(b(o) * 100) ? Math.max(...o) : 1, f = [], l = [];
+  return s.forEach((p, a) => {
+    const h = X(p, n, r + 1);
+    h && (f.push(h), l.push(c ? (o[a] ?? u) / u : 1));
+  }), f.length === 0 ? null : { type: "split", id: e, direction: i, children: f, sizes: l };
+}
+function Z(t) {
+  if (t.type === "group") return t.tabs.length > 0 ? t : null;
+  const n = [], r = [];
+  return t.children.forEach((e, i) => {
+    const s = Z(e);
+    s && (n.push(s), r.push(t.sizes[i] ?? 0));
+  }), n.length > 0 ? { ...t, children: n, sizes: r } : null;
+}
+function q(t, n = 100, r = 100) {
+  if (t.type === "group") return t;
+  const e = t.direction === "row", i = e ? n : r, s = i > 0 ? k / i * 100 : 100;
+  let o = t.sizes;
+  if (s * o.length >= 100)
+    o.some((f) => Math.abs(f - 100 / t.sizes.length) > P) && (o = o.map(() => 100 / t.sizes.length));
+  else if (o.some((f) => f < s)) {
+    const f = b(o.map((p) => Math.max(0, s - p))), l = b(o.map((p) => Math.max(0, p - s)));
+    o = o.map((p) => p < s ? s : p - (p - s) * f / l);
+  }
+  let c = o !== t.sizes;
+  const u = t.children.map((f, l) => {
+    const p = (o[l] ?? 0) / 100, a = q(f, e ? n * p : n, e ? r : r * p);
+    return a !== f && (c = !0), a;
+  });
+  return c ? { ...t, children: u, sizes: o } : t;
+}
+function ft(t) {
+  const n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+  if (L(t, (s) => {
+    s.id !== "" && !n.has(s.id) ? n.add(s.id) : r.add(s);
+  }), r.size === 0) return t;
+  const e = { g: 0, s: 0 };
+  n.forEach((s) => {
+    const o = /^(\D+)(\d+)$/.exec(s);
+    o && (o[1] === "g" || o[1] === "s") && (e[o[1]] = Math.max(e[o[1]], Number(o[2])));
+  });
+  const i = (s) => {
+    const o = s.type === "group" ? "g" : "s", c = r.has(s) ? `${o}${++e[o]}` : s.id;
+    return s.type === "group" ? { ...s, id: c } : { ...s, id: c, children: s.children.map(i) };
+  };
+  return i(t);
+}
+function bt(t, n = {}) {
+  if (!I(t) || t.version !== 1) return null;
+  const r = X(t.root, /* @__PURE__ */ new Set());
+  if (!r) return null;
+  const e = Z(r), i = ft(
+    e ? q(w(e)) : { type: "group", id: N(r).id, tabs: [], active: null }
+  ), s = R(i, []), o = s.some((u) => u.id === t.activeGroup) ? t.activeGroup : d(s, 0).id, c = { version: 1, root: i, activeGroup: o };
+  return n.tabs ? pt(c, n.tabs) : c;
+}
+function pt(t, n) {
+  const r = new Set(n);
+  let e = t;
+  return _(t).forEach(
+    (i) => i.tabs.forEach((s) => {
+      r.has(s) || (e = lt(e, s));
+    })
+  ), n.forEach((i) => {
+    $(e, i) || (e = K(e, i, { select: !1 }));
+  }), e;
+}
+function _(t) {
+  return R(t.root, []);
+}
+function $(t, n) {
+  return _(t).find((r) => r.tabs.includes(n));
+}
+function K(t, n, r = {}) {
+  const e = S(t, r.group ?? t.activeGroup);
+  if (!e) return t;
+  const i = r.select ?? !0, s = $(t, n);
+  if (s && s.id === e.id) {
+    const f = W(t, s, n, r.index);
+    return i ? at(f, n) : f;
+  }
+  let o = t.root, c = !1;
+  s && ({ root: o, closed: c } = U(o, s, n)), o = ct(o, e.id, n, r.index, i);
+  const u = i ? e.id : c ? H(t, o, t.activeGroup) : t.activeGroup;
+  return A(t, o, u);
+}
+function lt(t, n) {
+  const r = $(t, n);
+  if (!r) return t;
+  const { root: e } = U(t.root, r, n);
+  return A(t, e, H(t, e, t.activeGroup));
+}
+function at(t, n) {
+  const r = $(t, n);
+  if (!r) return t;
+  const e = r.active === n ? t.root : F(t.root, { ...r, active: n });
+  return A(t, e, r.id);
+}
+function Tt(t, n) {
+  return S(t, n) ? A(t, t.root, n) : t;
+}
+function W(t, n, r, e) {
+  const i = n.tabs.indexOf(r), s = n.tabs.length - 1, o = z(e ?? s, 0, s);
+  if (o === i) return t;
+  const c = n.tabs.slice();
+  return c.splice(i, 1), c.splice(o, 0, r), A(t, F(t.root, { ...n, tabs: c }));
+}
+function D(t, n, r) {
+  const e = $(t, n), i = S(t, r.group);
+  if (!e || !i) return t;
+  if (r.edge === void 0)
+    return i.id === e.id ? W(t, e, n, r.index) : K(t, n, {
+      group: i.id,
+      ...r.index === void 0 ? {} : { index: r.index }
+    });
+  if (i.id === e.id && e.tabs.length < 2) return t;
+  const s = C(t.root, "g"), o = C(t.root, "s"), { root: c } = U(t.root, e, n), u = { type: "group", id: s, tabs: [n], active: n };
+  return A(t, ut(c, i.id, u, r.edge, o), s);
+}
+function Gt(t, n, r) {
+  const e = $(t, n);
+  if (!e) return t;
+  const i = mt(t, e.id, r);
+  return i !== void 0 ? D(t, n, { group: i }) : D(t, n, { group: e.id, edge: r });
+}
+function ht(t, n, r) {
+  let e = 100, i = t;
+  for (const s of n) {
+    if (i.type !== "split") break;
+    i.direction === r && (e *= (i.sizes[s] ?? 0) / (b(i.sizes) || 1)), i = d(i.children, s);
+  }
+  return e;
+}
+function J(t, n, r) {
+  if (t.type === "group") return r;
+  const e = t.children.map((s) => J(s, n, r));
+  if (t.direction !== n) return Math.max(...e);
+  const i = b(t.sizes) || 1;
+  return Math.max(
+    ...e.map((s, o) => {
+      const c = (t.sizes[o] ?? 0) / i;
+      return c > 0 ? s / c : Number.POSITIVE_INFINITY;
+    })
+  );
+}
+function At(t, n, r, e, i = 0) {
+  const s = G(t.root, n);
+  if (!s) return t;
+  const o = T(t.root, s);
+  if (o.type !== "split" || !Number.isInteger(r) || r < 0 || r >= o.children.length - 1 || Number.isNaN(e) || e === 0) return t;
+  const c = o.sizes[r] ?? 0, u = o.sizes[r + 1] ?? 0, f = c + u, l = ht(t.root, s, o.direction), p = l > 0 ? k / l * 100 : 0, a = (M) => Math.min(f, Math.max(p, J(M, o.direction, i > 0 ? i : 0)));
+  let h = a(d(o.children, r)), v = a(d(o.children, r + 1));
+  if (h + v > f) {
+    const M = f / (h + v);
+    h *= M, v *= M;
+  }
+  const g = z(c + e, h, f - v);
+  if (g === c) return t;
+  const E = o.sizes.slice();
+  return E[r] = g, E[r + 1] = f - g, A(t, m(t.root, s, { ...o, sizes: E }));
+}
+function B(t, n, r, e) {
+  if (t.type === "group") {
+    r(t, n);
+    return;
+  }
+  const i = b(t.sizes) || 1, s = t.direction === "row", o = s ? n.x0 : n.y0, c = s ? n.x1 - n.x0 : n.y1 - n.y0;
+  let u = 0;
+  t.children.forEach((f, l) => {
+    const p = o + c * u / i;
+    u += t.sizes[l] ?? 0;
+    const a = l === t.children.length - 1 ? s ? n.x1 : n.y1 : o + c * u / i, h = s ? { ...n, x0: p, x1: a } : { ...n, y0: p, y1: a };
+    B(f, h, r, e), e && l < t.children.length - 1 && e(t, l, a, n);
+  });
+}
+const Q = { x0: 0, y0: 0, x1: 100, y1: 100 };
+function dt(t) {
+  const n = [];
+  return B(t.root, Q, (r, e) => n.push({ group: r, rect: e })), n;
+}
+function mt(t, n, r) {
+  const e = dt(t), i = e.find((u) => u.group.id === n)?.rect;
+  if (!i) return;
+  const s = r === "left" || r === "right";
+  let o, c = x;
+  return e.forEach(({ group: u, rect: f }) => {
+    if (u.id === n || !(r === "right" ? Math.abs(f.x0 - i.x1) < x : r === "left" ? Math.abs(f.x1 - i.x0) < x : r === "bottom" ? Math.abs(f.y0 - i.y1) < x : Math.abs(f.y1 - i.y0) < x)) return;
+    const p = s ? Math.min(f.y1, i.y1) - Math.max(f.y0, i.y0) : Math.min(f.x1, i.x1) - Math.max(f.x0, i.x0);
+    p > c + P && (o = u.id, c = p);
+  }), o;
+}
+function vt(t, n) {
+  const r = G(t.root, n);
+  if (!r || r.length === 0 || T(t.root, r).type !== "group") return;
+  const e = T(t.root, r.slice(0, -1)), i = d(r, r.length - 1), s = e.children[i - 1];
+  if (s) return j(s).id;
+  const o = e.children[i + 1];
+  return o ? N(o).id : void 0;
+}
+function Et(t, n, r, e, i = 0.25) {
+  if (!(r > 0) || !(e > 0)) return "center";
+  const s = z(t, 0, r) / r, o = z(n, 0, e) / e, c = [
+    ["top", o],
+    ["right", 1 - s],
+    ["bottom", 1 - o],
+    ["left", s]
+  ];
+  let u = "center", f = 1 / 0;
+  return c.forEach(([l, p]) => {
+    p < i && p < f - it && (u = l, f = p);
+  }), u;
+}
+function V(t) {
+  const n = [];
+  return t.slice().sort((r, e) => r - e).forEach((r) => {
+    const e = n[n.length - 1];
+    (e === void 0 || r - e >= x) && n.push(r);
+  }), n;
+}
+function y(t, n) {
+  let r = 0;
+  return t.forEach((e, i) => {
+    e <= n + 1e-9 && (r = i);
+  }), r;
+}
+function O(t, n, r) {
+  const e = y(t, n);
+  return [e, Math.max(e + 1, y(t, r))];
+}
+function Y(t) {
+  return t.slice(1).map((n, r) => st(n - d(t, r)));
+}
+function zt(t) {
+  const n = [], r = [];
+  B(
+    t.root,
+    Q,
+    (c, u) => n.push({ group: c, rect: u }),
+    (c, u, f, l) => r.push({ split: c, index: u, position: f, rect: l })
+  );
+  const e = V(n.flatMap(({ rect: c }) => [c.x0, c.x1])), i = V(n.flatMap(({ rect: c }) => [c.y0, c.y1])), s = Y(e), o = Y(i);
+  return {
+    columns: s,
+    rows: o,
+    groups: n.map(({ group: c, rect: u }) => ({
+      id: c.id,
+      column: O(e, u.x0, u.x1),
+      row: O(i, u.y0, u.y1)
+    })),
+    separators: r.map(({ split: c, index: u, position: f, rect: l }) => {
+      const p = c.direction === "row", a = p ? s.length : o.length;
+      return {
+        split: c.id,
+        index: u,
+        orientation: p ? "vertical" : "horizontal",
+        line: z(y(p ? e : i, f), 1, Math.max(1, a - 1)),
+        span: p ? O(i, l.y0, l.y1) : O(e, l.x0, l.x1)
+      };
+    })
+  };
+}
+const tt = " var(--smwb-tab-groups-separator-size) ";
+function $t(t) {
+  return t.columns.map((n) => `minmax(0, ${n}fr)`).join(tt);
+}
+function Mt(t) {
+  return t.rows.map((n) => `auto minmax(0, ${n}fr)`).join(tt);
+}
+function Ot(t) {
+  const [n, r] = t.column, [e] = t.row;
+  return `${3 * e + 1} / ${2 * n + 1} / ${3 * e + 2} / ${2 * r}`;
+}
+function Rt(t) {
+  const [n, r] = t.column, [e, i] = t.row;
+  return `${3 * e + 2} / ${2 * n + 1} / ${3 * i} / ${2 * r}`;
+}
+function Nt(t) {
+  const n = t.line, [r, e] = t.span;
+  return t.orientation === "vertical" ? `${3 * r + 1} / ${2 * n} / ${3 * e} / ${2 * n + 1}` : `${3 * n} / ${2 * r + 1} / ${3 * n + 1} / ${2 * e}`;
+}
+function St(t, n, r, e = rt) {
+  if (t.type === "split") return e.movedToNewGroup(r(t.tab), t.edge);
+  if (t.type !== "move") return "";
+  if (t.from === t.to) {
+    const o = S(n, t.to), c = o ? o.tabs.indexOf(t.tab) + 1 : 0;
+    return e.movedInGroup(r(t.tab), c || t.index + 1, o?.tabs.length ?? 0);
+  }
+  const i = _(n), s = i.findIndex((o) => o.id === t.to);
+  return e.movedToGroup(r(t.tab), s + 1, i.length);
+}
+export {
+  rt as TAB_GROUPS_LABELS,
+  gt as TAB_GROUPS_LAYOUT_VERSION,
+  K as addTab,
+  vt as adjacentGroup,
+  zt as computeTabGroupsGrid,
+  xt as createTabGroupsLayout,
+  St as describeTabGroupsChange,
+  Et as dropZoneAt,
+  $ as findGroupOfTab,
+  _ as getGroups,
+  $t as gridTemplateColumns,
+  Mt as gridTemplateRows,
+  Rt as groupBodyArea,
+  Ot as groupHeaderArea,
+  D as moveTab,
+  Gt as moveTabInDirection,
+  mt as neighbourGroup,
+  bt as parseTabGroupsLayout,
+  lt as removeTab,
+  At as resizeSplit,
+  at as selectTab,
+  Nt as separatorArea,
+  Tt as setActiveGroup,
+  pt as syncTabs
+};
+//# sourceMappingURL=tabGroupsLayout.js.map

package/dist/headless/components/layout/tabGroups/tabGroupsLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabGroupsLayout.js","sources":["../../../../../src/components/layout/tabGroups/tabGroupsLayout.ts"],"sourcesContent":["/**\n * The pure layout model of `TabGroups`: the split tree, every operation on it and the grid\n * geometry drawn from it. There is no framework and no DOM here, so jsdom tests feed layouts\n * and numbers straight in, and the server and the client compute the same markup. The file is\n * a byte-identical copy in ui-react and ui-solid.\n *\n * Every operation is pure: it never mutates its input and returns the input object itself when\n * nothing changes. Unknown ids are no-ops, never errors.\n */\n\n/** The version of the layout JSON this model reads and writes. */\nexport const TAB_GROUPS_LAYOUT_VERSION = 1;\n\n/** An edge of a group: a tab dropped or moved there gets a new group on that side. */\nexport type TabGroupsEdge = \"top\" | \"right\" | \"bottom\" | \"left\";\n\n/** Where a drop over a group's body lands: into the group (`center`) or a new group at an edge. */\nexport type TabGroupsDropZone = \"center\" | TabGroupsEdge;\n\n/** A group: one tab row and its panels. */\nexport interface TabGroupsGroup {\n  type: \"group\";\n  /** Unique among all nodes. Generated ids are \"g1\", \"g2\", …; an app may use any string. */\n  id: string;\n  /** Tab ids in row order. A tab id appears in exactly one group. Empty only for the root group (nothing open). */\n  tabs: string[];\n  /** The selected tab: one of `tabs`; null only when `tabs` is empty. */\n  active: string | null;\n}\n\n/** A split of an area into side-by-side or stacked children. */\nexport interface TabGroupsSplit {\n  type: \"split\";\n  /** Unique among all nodes. Generated ids are \"s1\", \"s2\", …. */\n  id: string;\n  /** \"row\": children side by side, left to right; \"column\": stacked, top to bottom. */\n  direction: \"row\" | \"column\";\n  /** At least two. Never a split of the same direction (it is flattened into this one). */\n  children: TabGroupsNode[];\n  /** Each child's share of this split in percent, same length as `children`, positive, summing to 100. */\n  sizes: number[];\n}\n\n/** A node of the split tree. */\nexport type TabGroupsNode = TabGroupsGroup | TabGroupsSplit;\n\n/** The whole arrangement: what an app stores. Only ids and sizes, no labels or content. */\nexport interface TabGroupsLayout {\n  version: 1;\n  root: TabGroupsNode;\n  /** The group the user last worked in: new tabs go there by default. Always an existing group id. */\n  activeGroup: string;\n}\n\n/** What a layout change did: the second argument of `onLayoutChange`. */\nexport type TabGroupsChange =\n  | { type: \"select\"; tab: string; group: string }\n  /** Focus moved into another group. */\n  | { type: \"activate\"; group: string }\n  /** Into an existing group, including a reorder within the same group. */\n  | { type: \"move\"; tab: string; from: string; to: string; index: number; sourceClosed: boolean }\n  /** Into a new group at an edge; `to` is the new group. */\n  | { type: \"split\"; tab: string; from: string; to: string; edge: TabGroupsEdge; sourceClosed: boolean }\n  | { type: \"close\"; tab: string; group: string; groupClosed: boolean }\n  | { type: \"resize\"; split: string; sizes: number[] };\n\n/** Where `moveTab` puts a tab. */\nexport type TabGroupsMoveTarget =\n  /** Into an existing group; `index` = the tab's final index (default: the end). */\n  | { group: string; index?: number; edge?: undefined }\n  /** A new group at that edge of `group`. */\n  | { group: string; edge: TabGroupsEdge };\n\n/** The CSS grid a layout is drawn on (see `computeTabGroupsGrid`). */\nexport interface TabGroupsGrid {\n  /** Content column widths, percent, left to right. */\n  columns: number[];\n  /** Content row heights, percent, top to bottom. */\n  rows: number[];\n  /** Every group's content columns and rows, end-exclusive, in reading order. */\n  groups: { id: string; column: [number, number]; row: [number, number] }[];\n  /**\n   * Every separator, in reading order (after the subtree of child `index` of its split). `line` is the\n   * content boundary it sits on (1..n-1); `span` its extent across the other axis, end-exclusive.\n   */\n  separators: {\n    split: string;\n    index: number;\n    orientation: \"vertical\" | \"horizontal\";\n    line: number;\n    span: [number, number];\n  }[];\n}\n\n/** The texts of `TabGroups`. Numbers passed in are 1-based, as they are read out. */\nexport interface TabGroupsLabels {\n  /** The tab row's name: \"Group 1 of 4\"; \"Tabs\" when count is 1. */\n  group: (index: number, count: number) => string;\n  /** The group actions button: \"Group actions\". */\n  groupActions: string;\n  /** \"Split right\". */\n  splitRight: string;\n  /** \"Split down\". */\n  splitDown: string;\n  /** \"Move to previous group\". */\n  moveToPreviousGroup: string;\n  /** \"Move to next group\". */\n  moveToNextGroup: string;\n  /** \"Move tab left\". */\n  moveLeft: string;\n  /** \"Move tab right\". */\n  moveRight: string;\n  /** The separators: \"Resize groups\". */\n  resize: string;\n  /** \"Terminal moved to group 2 of 3\". */\n  movedToGroup: (tab: string, index: number, count: number) => string;\n  /** \"Terminal moved to a new group on the right\" (below, on the left, above). */\n  movedToNewGroup: (tab: string, edge: TabGroupsEdge) => string;\n  /** \"Terminal moved to position 2 of 4\". */\n  movedInGroup: (tab: string, position: number, count: number) => string;\n}\n\nconst NEW_GROUP_PLACES: Record<TabGroupsEdge, string> = {\n  top: \"above\",\n  right: \"on the right\",\n  bottom: \"below\",\n  left: \"on the left\",\n};\n\n/** The default (English) texts. */\nexport const TAB_GROUPS_LABELS: TabGroupsLabels = {\n  group: (index, count) => (count === 1 ? \"Tabs\" : `Group ${index} of ${count}`),\n  groupActions: \"Group actions\",\n  splitRight: \"Split right\",\n  splitDown: \"Split down\",\n  moveToPreviousGroup: \"Move to previous group\",\n  moveToNextGroup: \"Move to next group\",\n  moveLeft: \"Move tab left\",\n  moveRight: \"Move tab right\",\n  resize: \"Resize groups\",\n  movedToGroup: (tab, index, count) => `${tab} moved to group ${index} of ${count}`,\n  movedToNewGroup: (tab, edge) => `${tab} moved to a new group ${NEW_GROUP_PLACES[edge]}`,\n  movedInGroup: (tab, position, count) => `${tab} moved to position ${position} of ${count}`,\n};\n\n/** Grid boundaries closer than this (percent of the root) are one line. */\nconst SNAP = 0.05;\n/** Sizes summing to 100 within this are left as they are (float noise from halving and scaling). */\nconst SUM_TOLERANCE = 1e-6;\n/**\n * The least a group or split covers of the root along its split's axis, in percent: twice the\n * snap, so that its two edges never snap into one line and it keeps a grid track of its own.\n */\nconst MIN_EXTENT = SNAP * 2;\n/** How deep stored JSON may nest; a deeper node (or a cycle in an object) is not read. */\nconst MAX_DEPTH = 32;\n/**\n * Two edges of a drop area this close to the pointer (a fraction of it) are one tie, and the earlier\n * of the two wins. Without it the noise of `1 - 0.9` against `0.1` decides, and a corner that is\n * exactly as far from the top as from the right reads as the right edge.\n */\nconst ZONE_TOLERANCE = 1e-6;\n\n/** Child indexes from the root down to a node; `[]` is the root. */\ntype Path = number[];\n\n/** A rectangle in percent of the root: left/top inclusive, right/bottom the far edges. */\ninterface Rect {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/**\n * `items[index]` for an index the caller knows exists: one spelling for both packages (ui-solid\n * checks indexed access, ui-react does not). Only an internal bug can make it throw.\n */\nfunction itemAt<T>(items: readonly T[], index: number): T {\n  const item = items[index];\n  if (item === undefined) throw new RangeError(`tabGroupsLayout: no item at ${index}`);\n  return item;\n}\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.min(max, Math.max(min, value));\n}\n\nfunction round4(value: number): number {\n  return Math.round(value * 10000) / 10000;\n}\n\nfunction sum(values: readonly number[]): number {\n  return values.reduce((total, value) => total + value, 0);\n}\n\nfunction collectGroups(node: TabGroupsNode, out: TabGroupsGroup[]): TabGroupsGroup[] {\n  if (node.type === \"group\") out.push(node);\n  else node.children.forEach((child) => collectGroups(child, out));\n  return out;\n}\n\nfunction firstGroup(node: TabGroupsNode): TabGroupsGroup {\n  return node.type === \"group\" ? node : firstGroup(itemAt(node.children, 0));\n}\n\nfunction lastGroup(node: TabGroupsNode): TabGroupsGroup {\n  return node.type === \"group\" ? node : lastGroup(itemAt(node.children, node.children.length - 1));\n}\n\nfunction forEachNode(node: TabGroupsNode, visit: (node: TabGroupsNode) => void): void {\n  visit(node);\n  if (node.type === \"split\") node.children.forEach((child) => forEachNode(child, visit));\n}\n\nfunction findPath(node: TabGroupsNode, id: string, path: Path = []): Path | undefined {\n  if (node.id === id) return path;\n  if (node.type === \"group\") return undefined;\n  for (let index = 0; index < node.children.length; index++) {\n    const found = findPath(itemAt(node.children, index), id, [...path, index]);\n    if (found) return found;\n  }\n  return undefined;\n}\n\nfunction nodeAt(root: TabGroupsNode, path: Path): TabGroupsNode {\n  let node = root;\n  for (const index of path) node = itemAt((node as TabGroupsSplit).children, index);\n  return node;\n}\n\n/** A copy of `root` with the node at `path` replaced; nodes off the path are shared. */\nfunction replaceAt(root: TabGroupsNode, path: Path, replacement: TabGroupsNode): TabGroupsNode {\n  if (path.length === 0) return replacement;\n  const split = root as TabGroupsSplit;\n  const [index, ...rest] = path as [number, ...number[]];\n  const children = split.children.slice();\n  children[index] = replaceAt(itemAt(children, index), rest, replacement);\n  return { ...split, children };\n}\n\nfunction getGroup(layout: TabGroupsLayout, groupId: string): TabGroupsGroup | undefined {\n  return getGroups(layout).find((group) => group.id === groupId);\n}\n\nfunction replaceGroup(root: TabGroupsNode, group: TabGroupsGroup): TabGroupsNode {\n  const path = findPath(root, group.id);\n  return path ? replaceAt(root, path, group) : root;\n}\n\nfunction withRoot(layout: TabGroupsLayout, root: TabGroupsNode, activeGroup = layout.activeGroup): TabGroupsLayout {\n  if (root === layout.root && activeGroup === layout.activeGroup) return layout;\n  return { version: TAB_GROUPS_LAYOUT_VERSION, root, activeGroup };\n}\n\n/** `activeGroup` after a change: `wanted` if it still exists, else the group that took its space, else the first. */\nfunction resolveActiveGroup(before: TabGroupsLayout, root: TabGroupsNode, wanted: string): string {\n  const exists = (id: string | undefined) =>\n    id !== undefined && collectGroups(root, []).some((group) => group.id === id);\n  if (exists(wanted)) return wanted;\n  const heir = adjacentGroup(before, wanted);\n  return heir !== undefined && exists(heir) ? heir : firstGroup(root).id;\n}\n\n/** \"g8\" when the largest number used with prefix \"g\" by any node is 7; \"g1\" when none is. */\nfunction nextId(root: TabGroupsNode, prefix: \"g\" | \"s\"): string {\n  let max = 0;\n  forEachNode(root, (node) => {\n    const match = /^(\\D+)(\\d+)$/.exec(node.id);\n    if (match && match[1] === prefix) max = Math.max(max, Number(match[2]));\n  });\n  return `${prefix}${max + 1}`;\n}\n\n/**\n * Collapses splits left with one child, flattens a child split of its parent's direction into\n * the parent (sizes scaled) and rescales sizes that do not sum to 100. Unchanged subtrees keep\n * their identity, so a normalized tree comes back as the same object.\n */\nfunction normalize(node: TabGroupsNode): TabGroupsNode {\n  if (node.type === \"group\") return node;\n  let changed = false;\n  const children: TabGroupsNode[] = [];\n  let sizes: number[] = [];\n  node.children.forEach((child, index) => {\n    const size = node.sizes[index] ?? 0;\n    const next = normalize(child);\n    if (next !== child) changed = true;\n    if (next.type === \"split\" && next.direction === node.direction) {\n      changed = true;\n      next.children.forEach((grandchild, inner) => {\n        children.push(grandchild);\n        sizes.push((size * (next.sizes[inner] ?? 0)) / 100);\n      });\n    } else {\n      children.push(next);\n      sizes.push(size);\n    }\n  });\n  if (children.length === 1) return itemAt(children, 0);\n  const total = sum(sizes);\n  if (total > 0 && Math.abs(total - 100) > SUM_TOLERANCE) {\n    changed = true;\n    sizes = sizes.map((size) => (size * 100) / total);\n  }\n  return changed ? { ...node, children, sizes } : node;\n}\n\n/** Removes the node at `path` (not the root); its share goes to the previous sibling, else the next. */\nfunction removeAt(root: TabGroupsNode, path: Path): TabGroupsNode {\n  const parentPath = path.slice(0, -1);\n  const index = itemAt(path, path.length - 1);\n  const parent = nodeAt(root, parentPath) as TabGroupsSplit;\n  const heir = index > 0 ? index - 1 : index + 1;\n  const sizes = parent.sizes.slice();\n  sizes[heir] = (sizes[heir] ?? 0) + (sizes[index] ?? 0);\n  sizes.splice(index, 1);\n  const children = parent.children.filter((_, i) => i !== index);\n  return normalize(replaceAt(root, parentPath, { ...parent, children, sizes }));\n}\n\n/**\n * Takes a tab out of its group. When the closed tab was selected, the tab that takes its place\n * (the previous one if it was last) is selected. An emptied group other than the root is removed.\n */\nfunction detachTab(\n  root: TabGroupsNode,\n  group: TabGroupsGroup,\n  tabId: string\n): { root: TabGroupsNode; closed: boolean } {\n  const path = findPath(root, group.id)!;\n  const index = group.tabs.indexOf(tabId);\n  const tabs = group.tabs.filter((tab) => tab !== tabId);\n  if (tabs.length === 0 && path.length > 0) return { root: removeAt(root, path), closed: true };\n  const active = group.active === tabId ? (tabs[index] ?? tabs[index - 1] ?? null) : group.active;\n  return { root: replaceAt(root, path, { ...group, tabs, active }), closed: false };\n}\n\n/** Puts a tab into a group at `index` (clamped; default the end). */\nfunction insertTab(\n  root: TabGroupsNode,\n  groupId: string,\n  tabId: string,\n  index: number | undefined,\n  select: boolean\n): TabGroupsNode {\n  const path = findPath(root, groupId)!;\n  const group = nodeAt(root, path) as TabGroupsGroup;\n  const tabs = group.tabs.slice();\n  tabs.splice(clamp(index ?? tabs.length, 0, tabs.length), 0, tabId);\n  const active = select || group.active === null ? tabId : group.active;\n  return replaceAt(root, path, { ...group, tabs, active });\n}\n\n/** Puts `node` at `edge` of the node `targetId`: beside it in a split along that axis, else in a new 50/50 split. */\nfunction insertBeside(\n  root: TabGroupsNode,\n  targetId: string,\n  node: TabGroupsNode,\n  edge: TabGroupsEdge,\n  splitId: string\n): TabGroupsNode {\n  const path = findPath(root, targetId)!;\n  const direction = edge === \"left\" || edge === \"right\" ? \"row\" : \"column\";\n  const before = edge === \"left\" || edge === \"top\";\n  if (path.length > 0) {\n    const parentPath = path.slice(0, -1);\n    const index = itemAt(path, path.length - 1);\n    const parent = nodeAt(root, parentPath) as TabGroupsSplit;\n    if (parent.direction === direction) {\n      const half = (parent.sizes[index] ?? 0) / 2;\n      const children = parent.children.slice();\n      const sizes = parent.sizes.slice();\n      sizes[index] = half;\n      const at = before ? index : index + 1;\n      children.splice(at, 0, node);\n      sizes.splice(at, 0, half);\n      return replaceAt(root, parentPath, { ...parent, children, sizes });\n    }\n  }\n  const target = nodeAt(root, path);\n  const split: TabGroupsSplit = {\n    type: \"split\",\n    id: splitId,\n    direction,\n    children: before ? [node, target] : [target, node],\n    sizes: [50, 50],\n  };\n  return replaceAt(root, path, split);\n}\n\n/** A layout of one group \"g1\" holding `tabs`; `active` (when one of them) or the first is selected. */\nexport function createTabGroupsLayout(\n  tabs: readonly string[] = [],\n  options: { active?: string } = {}\n): TabGroupsLayout {\n  const unique = Array.from(new Set(tabs));\n  const active = options.active !== undefined && unique.includes(options.active) ? options.active : (unique[0] ?? null);\n  return {\n    version: TAB_GROUPS_LAYOUT_VERSION,\n    root: { type: \"group\", id: \"g1\", tabs: unique, active },\n    activeGroup: \"g1\",\n  };\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * Reads one node of untrusted JSON; tab ids already taken (`seen`) are dropped. Ids are fixed later.\n * A node deeper than `MAX_DEPTH` is not read, which also ends a cycle.\n */\nfunction readNode(raw: unknown, seen: Set<string>, depth = 0): TabGroupsNode | null {\n  if (!isRecord(raw) || depth > MAX_DEPTH) return null;\n  const id = typeof raw.id === \"string\" ? raw.id : \"\";\n  if (raw.type === \"group\") {\n    const tabs: string[] = [];\n    if (Array.isArray(raw.tabs)) {\n      for (const tab of raw.tabs as unknown[]) {\n        if (typeof tab !== \"string\" || seen.has(tab)) continue;\n        seen.add(tab);\n        tabs.push(tab);\n      }\n    }\n    const active = typeof raw.active === \"string\" && tabs.includes(raw.active) ? raw.active : (tabs[0] ?? null);\n    return { type: \"group\", id, tabs, active };\n  }\n  const direction = raw.direction;\n  if (raw.type !== \"split\" || (direction !== \"row\" && direction !== \"column\") || !Array.isArray(raw.children)) {\n    return null;\n  }\n  const rawChildren = raw.children as unknown[];\n  const rawSizes = raw.sizes;\n  const validSizes =\n    Array.isArray(rawSizes) &&\n    rawSizes.length === rawChildren.length &&\n    (rawSizes as unknown[]).every((size) => typeof size === \"number\" && Number.isFinite(size) && size > 0);\n  // Sizes near the float limit are read relative to the largest, so that they still add up (and\n  // rescale) to numbers; any others as they are, so that a stored layout reads back unchanged.\n  const scale =\n    validSizes && !Number.isFinite(sum(rawSizes as number[]) * 100) ? Math.max(...(rawSizes as number[])) : 1;\n  const children: TabGroupsNode[] = [];\n  const sizes: number[] = [];\n  rawChildren.forEach((rawChild, index) => {\n    const child = readNode(rawChild, seen, depth + 1);\n    if (!child) return;\n    children.push(child);\n    // Equal shares when the sizes are unusable; `normalize` rescales to 100.\n    sizes.push(validSizes ? ((rawSizes as number[])[index] ?? scale) / scale : 1);\n  });\n  if (children.length === 0) return null;\n  return { type: \"split\", id, direction, children, sizes };\n}\n\n/** Drops empty groups and the splits left without children; null when nothing is left. */\nfunction pruneEmpty(node: TabGroupsNode): TabGroupsNode | null {\n  if (node.type === \"group\") return node.tabs.length > 0 ? node : null;\n  const children: TabGroupsNode[] = [];\n  const sizes: number[] = [];\n  node.children.forEach((child, index) => {\n    const next = pruneEmpty(child);\n    if (!next) return;\n    children.push(next);\n    sizes.push(node.sizes[index] ?? 0);\n  });\n  return children.length > 0 ? { ...node, children, sizes } : null;\n}\n\n/**\n * Raises every share that the grid could not draw — a child covering less than `MIN_EXTENT` of the\n * root along its split's axis would snap into its neighbour's track — to that minimum, taking the\n * difference from its siblings above it; equal shares when the split is too small for that.\n * `width` and `height` are the node's extent in percent of the root. Sizes must sum to 100.\n */\nfunction keepDrawable(node: TabGroupsNode, width = 100, height = 100): TabGroupsNode {\n  if (node.type === \"group\") return node;\n  const row = node.direction === \"row\";\n  const extent = row ? width : height;\n  const floor = extent > 0 ? (MIN_EXTENT / extent) * 100 : 100;\n  let sizes = node.sizes;\n  if (floor * sizes.length >= 100) {\n    if (sizes.some((size) => Math.abs(size - 100 / node.sizes.length) > SUM_TOLERANCE)) {\n      sizes = sizes.map(() => 100 / node.sizes.length);\n    }\n  } else if (sizes.some((size) => size < floor)) {\n    const short = sum(sizes.map((size) => Math.max(0, floor - size)));\n    const spare = sum(sizes.map((size) => Math.max(0, size - floor)));\n    sizes = sizes.map((size) => (size < floor ? floor : size - ((size - floor) * short) / spare));\n  }\n  let changed = sizes !== node.sizes;\n  const children = node.children.map((child, index) => {\n    const share = (sizes[index] ?? 0) / 100;\n    const next = keepDrawable(child, row ? width * share : width, row ? height : height * share);\n    if (next !== child) changed = true;\n    return next;\n  });\n  return changed ? { ...node, children, sizes } : node;\n}\n\n/** Regenerates missing and duplicate node ids (the first in reading order keeps its id). */\nfunction assignIds(root: TabGroupsNode): TabGroupsNode {\n  const used = new Set<string>();\n  const missing = new Set<TabGroupsNode>();\n  forEachNode(root, (node) => {\n    if (node.id !== \"\" && !used.has(node.id)) used.add(node.id);\n    else missing.add(node);\n  });\n  if (missing.size === 0) return root;\n  const counters = { g: 0, s: 0 };\n  used.forEach((id) => {\n    const match = /^(\\D+)(\\d+)$/.exec(id);\n    if (match && (match[1] === \"g\" || match[1] === \"s\")) {\n      counters[match[1]] = Math.max(counters[match[1]], Number(match[2]));\n    }\n  });\n  const rebuild = (node: TabGroupsNode): TabGroupsNode => {\n    const prefix = node.type === \"group\" ? \"g\" : \"s\";\n    const id = missing.has(node) ? `${prefix}${++counters[prefix]}` : node.id;\n    return node.type === \"group\" ? { ...node, id } : { ...node, id, children: node.children.map(rebuild) };\n  };\n  return rebuild(root);\n}\n\n/**\n * Reads a layout from untrusted JSON (storage, a URL, a file). `null` for a non-object, a version\n * other than 1 or no valid root; anything else is repaired: non-string and duplicate tab ids\n * dropped (the first in reading order wins), empty non-root groups removed and splits collapsed\n * or flattened, an invalid `active` replaced by the first tab, unusable sizes replaced by equal\n * shares and all sizes rescaled to 100, missing or duplicate node ids regenerated, an invalid\n * `activeGroup` replaced by the first group. With `options.tabs` the layout is synced to that\n * list (`syncTabs`). A layout produced by this model round-trips through JSON unchanged.\n */\nexport function parseTabGroupsLayout(raw: unknown, options: { tabs?: readonly string[] } = {}): TabGroupsLayout | null {\n  if (!isRecord(raw) || raw.version !== TAB_GROUPS_LAYOUT_VERSION) return null;\n  const parsed = readNode(raw.root, new Set());\n  if (!parsed) return null;\n  const pruned = pruneEmpty(parsed);\n  const root = assignIds(\n    pruned ? keepDrawable(normalize(pruned)) : { type: \"group\", id: firstGroup(parsed).id, tabs: [], active: null }\n  );\n  const groups = collectGroups(root, []);\n  const activeGroup = groups.some((group) => group.id === raw.activeGroup)\n    ? (raw.activeGroup as string)\n    : itemAt(groups, 0).id;\n  const layout: TabGroupsLayout = { version: TAB_GROUPS_LAYOUT_VERSION, root, activeGroup };\n  return options.tabs ? syncTabs(layout, options.tabs) : layout;\n}\n\n/** Makes the layout hold exactly `tabs`: unknown ids are closed, missing ones appended to `activeGroup`. */\nexport function syncTabs(layout: TabGroupsLayout, tabs: readonly string[]): TabGroupsLayout {\n  const wanted = new Set(tabs);\n  let next = layout;\n  getGroups(layout).forEach((group) =>\n    group.tabs.forEach((tab) => {\n      if (!wanted.has(tab)) next = removeTab(next, tab);\n    })\n  );\n  tabs.forEach((tab) => {\n    if (!findGroupOfTab(next, tab)) next = addTab(next, tab, { select: false });\n  });\n  return next;\n}\n\n/** Every group in reading order (depth first): the order \"Group n of N\" counts in. */\nexport function getGroups(layout: TabGroupsLayout): TabGroupsGroup[] {\n  return collectGroups(layout.root, []);\n}\n\n/** The group holding `tabId`. */\nexport function findGroupOfTab(layout: TabGroupsLayout, tabId: string): TabGroupsGroup | undefined {\n  return getGroups(layout).find((group) => group.tabs.includes(tabId));\n}\n\n/**\n * Adds a tab to `options.group` (default `activeGroup`) at `options.index` (default the end),\n * selected unless `options.select` is false. An id already in the layout moves there instead.\n */\nexport function addTab(\n  layout: TabGroupsLayout,\n  tabId: string,\n  options: { group?: string; index?: number; select?: boolean } = {}\n): TabGroupsLayout {\n  const target = getGroup(layout, options.group ?? layout.activeGroup);\n  if (!target) return layout;\n  const select = options.select ?? true;\n  const source = findGroupOfTab(layout, tabId);\n  if (source && source.id === target.id) {\n    const moved = reorderTab(layout, source, tabId, options.index);\n    return select ? selectTab(moved, tabId) : moved;\n  }\n  let root = layout.root;\n  let closed = false;\n  if (source) ({ root, closed } = detachTab(root, source, tabId));\n  root = insertTab(root, target.id, tabId, options.index, select);\n  const activeGroup = select\n    ? target.id\n    : closed\n      ? resolveActiveGroup(layout, root, layout.activeGroup)\n      : layout.activeGroup;\n  return withRoot(layout, root, activeGroup);\n}\n\n/**\n * Closes a tab. When it was its group's last tab the group goes too: its share passes to the\n * previous sibling (else the next), a split left with one child is replaced by that child and\n * `activeGroup` moves to the group that took the space. The last tab of the last group leaves\n * an empty root group.\n */\nexport function removeTab(layout: TabGroupsLayout, tabId: string): TabGroupsLayout {\n  const group = findGroupOfTab(layout, tabId);\n  if (!group) return layout;\n  const { root } = detachTab(layout.root, group, tabId);\n  return withRoot(layout, root, resolveActiveGroup(layout, root, layout.activeGroup));\n}\n\n/** Selects a tab in its group and makes that group `activeGroup`. */\nexport function selectTab(layout: TabGroupsLayout, tabId: string): TabGroupsLayout {\n  const group = findGroupOfTab(layout, tabId);\n  if (!group) return layout;\n  const root = group.active === tabId ? layout.root : replaceGroup(layout.root, { ...group, active: tabId });\n  return withRoot(layout, root, group.id);\n}\n\n/** Makes an existing group `activeGroup`. */\nexport function setActiveGroup(layout: TabGroupsLayout, groupId: string): TabGroupsLayout {\n  return getGroup(layout, groupId) ? withRoot(layout, layout.root, groupId) : layout;\n}\n\nfunction reorderTab(\n  layout: TabGroupsLayout,\n  group: TabGroupsGroup,\n  tabId: string,\n  index: number | undefined\n): TabGroupsLayout {\n  const from = group.tabs.indexOf(tabId);\n  const last = group.tabs.length - 1;\n  const to = clamp(index ?? last, 0, last);\n  if (to === from) return layout;\n  const tabs = group.tabs.slice();\n  tabs.splice(from, 1);\n  tabs.splice(to, 0, tabId);\n  return withRoot(layout, replaceGroup(layout.root, { ...group, tabs }));\n}\n\n/**\n * Moves a tab. Into another group: inserted at `target.index` (its final index; default the end),\n * selected there, and that group becomes `activeGroup`. Within its own group: a reorder, the\n * selection stays. To an edge: a new group there holding the tab (see `TabGroupsEdge`); the own\n * edge of a group with one tab is a no-op. A source group left empty closes as in `removeTab`.\n */\nexport function moveTab(layout: TabGroupsLayout, tabId: string, target: TabGroupsMoveTarget): TabGroupsLayout {\n  const source = findGroupOfTab(layout, tabId);\n  const destination = getGroup(layout, target.group);\n  if (!source || !destination) return layout;\n  if (target.edge === undefined) {\n    if (destination.id === source.id) return reorderTab(layout, source, tabId, target.index);\n    return addTab(layout, tabId, {\n      group: destination.id,\n      ...(target.index === undefined ? {} : { index: target.index }),\n    });\n  }\n  if (destination.id === source.id && source.tabs.length < 2) return layout;\n  const groupId = nextId(layout.root, \"g\");\n  const splitId = nextId(layout.root, \"s\");\n  const { root } = detachTab(layout.root, source, tabId);\n  const group: TabGroupsGroup = { type: \"group\", id: groupId, tabs: [tabId], active: tabId };\n  return withRoot(layout, insertBeside(root, destination.id, group, target.edge, splitId), groupId);\n}\n\n/**\n * The keyboard move (Alt+Shift+Arrow): into the neighbouring group at that edge (appended,\n * selected); with no neighbour and at least two tabs in the group, a new group at that edge;\n * otherwise nothing.\n */\nexport function moveTabInDirection(layout: TabGroupsLayout, tabId: string, edge: TabGroupsEdge): TabGroupsLayout {\n  const group = findGroupOfTab(layout, tabId);\n  if (!group) return layout;\n  const neighbour = neighbourGroup(layout, group.id, edge);\n  if (neighbour !== undefined) return moveTab(layout, tabId, { group: neighbour });\n  return moveTab(layout, tabId, { group: group.id, edge });\n}\n\n/** How much of the root a node covers along `direction`'s axis, in percent: its share of each split of that direction above it. */\nfunction extentAlong(root: TabGroupsNode, path: Path, direction: TabGroupsSplit[\"direction\"]): number {\n  let extent = 100;\n  let node = root;\n  for (const index of path) {\n    if (node.type !== \"split\") break;\n    if (node.direction === direction) extent *= (node.sizes[index] ?? 0) / (sum(node.sizes) || 1);\n    node = itemAt(node.children, index);\n  }\n  return extent;\n}\n\n/**\n * The least share of a split one of its children needs so that every group inside it keeps `min`\n * (both in percent of that split): `min` for a group, the most any child needs across the axis,\n * and along it the tightest child — a nested split keeps its proportions as it shrinks.\n */\nfunction leastShare(node: TabGroupsNode, direction: TabGroupsSplit[\"direction\"], min: number): number {\n  if (node.type === \"group\") return min;\n  const parts = node.children.map((child) => leastShare(child, direction, min));\n  if (node.direction !== direction) return Math.max(...parts);\n  const total = sum(node.sizes) || 1;\n  return Math.max(\n    ...parts.map((part, index) => {\n      const fraction = (node.sizes[index] ?? 0) / total;\n      return fraction > 0 ? part / fraction : Number.POSITIVE_INFINITY;\n    })\n  );\n}\n\n/**\n * Moves separator `index` of a split (between children `index` and `index + 1`) by `delta`\n * percent of the split (±Infinity: to the limit). Only that pair changes and the sizes still sum\n * to 100. Every group on both sides keeps at least `min` percent of the split (default 0) — a\n * nested split as a whole is held to what its groups need — and never so little that the grid\n * could not draw it (a few hundredths of a percent of the root).\n */\nexport function resizeSplit(\n  layout: TabGroupsLayout,\n  splitId: string,\n  index: number,\n  delta: number,\n  min = 0\n): TabGroupsLayout {\n  const path = findPath(layout.root, splitId);\n  if (!path) return layout;\n  const split = nodeAt(layout.root, path);\n  if (split.type !== \"split\" || !Number.isInteger(index) || index < 0 || index >= split.children.length - 1) {\n    return layout;\n  }\n  if (Number.isNaN(delta) || delta === 0) return layout;\n  const first = split.sizes[index] ?? 0;\n  const second = split.sizes[index + 1] ?? 0;\n  const pair = first + second;\n  const extent = extentAlong(layout.root, path, split.direction);\n  const floor = extent > 0 ? (MIN_EXTENT / extent) * 100 : 0;\n  const least = (child: TabGroupsNode): number =>\n    Math.min(pair, Math.max(floor, leastShare(child, split.direction, min > 0 ? min : 0)));\n  let lowFirst = least(itemAt(split.children, index));\n  let lowSecond = least(itemAt(split.children, index + 1));\n  // Both cannot have what they need: the pair is shared in proportion to it.\n  if (lowFirst + lowSecond > pair) {\n    const scale = pair / (lowFirst + lowSecond);\n    lowFirst *= scale;\n    lowSecond *= scale;\n  }\n  const next = clamp(first + delta, lowFirst, pair - lowSecond);\n  if (next === first) return layout;\n  const sizes = split.sizes.slice();\n  sizes[index] = next;\n  sizes[index + 1] = pair - next;\n  return withRoot(layout, replaceAt(layout.root, path, { ...split, sizes }));\n}\n\n/** Walks the tree with each node's rectangle; `onSeparator` runs after the subtree of each child but the last. */\nfunction walkRects(\n  node: TabGroupsNode,\n  rect: Rect,\n  onGroup: (group: TabGroupsGroup, rect: Rect) => void,\n  onSeparator?: (split: TabGroupsSplit, index: number, position: number, rect: Rect) => void\n): void {\n  if (node.type === \"group\") {\n    onGroup(node, rect);\n    return;\n  }\n  const total = sum(node.sizes) || 1;\n  const row = node.direction === \"row\";\n  const start = row ? rect.x0 : rect.y0;\n  const extent = row ? rect.x1 - rect.x0 : rect.y1 - rect.y0;\n  let offset = 0;\n  node.children.forEach((child, index) => {\n    const from = start + (extent * offset) / total;\n    offset += node.sizes[index] ?? 0;\n    // The last child ends exactly on the parent's edge, so shared boundaries compare equal.\n    const to = index === node.children.length - 1 ? (row ? rect.x1 : rect.y1) : start + (extent * offset) / total;\n    const childRect = row ? { ...rect, x0: from, x1: to } : { ...rect, y0: from, y1: to };\n    walkRects(child, childRect, onGroup, onSeparator);\n    if (onSeparator && index < node.children.length - 1) onSeparator(node, index, to, rect);\n  });\n}\n\nconst ROOT_RECT: Rect = { x0: 0, y0: 0, x1: 100, y1: 100 };\n\nfunction groupRects(layout: TabGroupsLayout): { group: TabGroupsGroup; rect: Rect }[] {\n  const out: { group: TabGroupsGroup; rect: Rect }[] = [];\n  walkRects(layout.root, ROOT_RECT, (group, rect) => out.push({ group, rect }));\n  return out;\n}\n\n/**\n * The group touching `edge` of the group `groupId` with the largest overlap along that edge\n * (ties: the first in reading order); undefined at the area's outer edge.\n */\nexport function neighbourGroup(layout: TabGroupsLayout, groupId: string, edge: TabGroupsEdge): string | undefined {\n  const rects = groupRects(layout);\n  const own = rects.find((entry) => entry.group.id === groupId)?.rect;\n  if (!own) return undefined;\n  const horizontal = edge === \"left\" || edge === \"right\";\n  let best: string | undefined;\n  let bestOverlap = SNAP;\n  rects.forEach(({ group, rect }) => {\n    if (group.id === groupId) return;\n    const touches =\n      edge === \"right\"\n        ? Math.abs(rect.x0 - own.x1) < SNAP\n        : edge === \"left\"\n          ? Math.abs(rect.x1 - own.x0) < SNAP\n          : edge === \"bottom\"\n            ? Math.abs(rect.y0 - own.y1) < SNAP\n            : Math.abs(rect.y1 - own.y0) < SNAP;\n    if (!touches) return;\n    const overlap = horizontal\n      ? Math.min(rect.y1, own.y1) - Math.max(rect.y0, own.y0)\n      : Math.min(rect.x1, own.x1) - Math.max(rect.x0, own.x0);\n    if (overlap > bestOverlap + SUM_TOLERANCE) {\n      best = group.id;\n      bestOverlap = overlap;\n    }\n  });\n  return best;\n}\n\n/**\n * The group that takes the space of `groupId` when it closes: the previous sibling's last group\n * in reading order, else the next sibling's first group; undefined for the root group.\n */\nexport function adjacentGroup(layout: TabGroupsLayout, groupId: string): string | undefined {\n  const path = findPath(layout.root, groupId);\n  if (!path || path.length === 0 || nodeAt(layout.root, path).type !== \"group\") return undefined;\n  const parent = nodeAt(layout.root, path.slice(0, -1)) as TabGroupsSplit;\n  const index = itemAt(path, path.length - 1);\n  const previous = parent.children[index - 1];\n  if (previous) return lastGroup(previous).id;\n  const next = parent.children[index + 1];\n  return next ? firstGroup(next).id : undefined;\n}\n\n/**\n * The drop zone under a point of a group's body (`x`, `y` relative to it, clamped into it): within\n * `edgeSize` (a fraction, default 0.25) of an edge, that edge; the nearest edge wins where bands\n * overlap (ties: top, right, bottom, left); else `center`.\n */\nexport function dropZoneAt(x: number, y: number, width: number, height: number, edgeSize = 0.25): TabGroupsDropZone {\n  if (!(width > 0) || !(height > 0)) return \"center\";\n  const px = clamp(x, 0, width) / width;\n  const py = clamp(y, 0, height) / height;\n  const distances: [TabGroupsEdge, number][] = [\n    [\"top\", py],\n    [\"right\", 1 - px],\n    [\"bottom\", 1 - py],\n    [\"left\", px],\n  ];\n  let zone: TabGroupsDropZone = \"center\";\n  let nearest = Infinity;\n  distances.forEach(([edge, distance]) => {\n    // Only a distance smaller by more than the tolerance takes over, so a tie stays with the\n    // earlier edge: top, then right, then bottom, then left.\n    if (distance < edgeSize && distance < nearest - ZONE_TOLERANCE) {\n      zone = edge;\n      nearest = distance;\n    }\n  });\n  return zone;\n}\n\n/** Sorted distinct boundaries; one closer than `SNAP` to the line before it joins that line. */\nfunction snapLines(values: number[]): number[] {\n  const lines: number[] = [];\n  values\n    .slice()\n    .sort((a, b) => a - b)\n    .forEach((value) => {\n      const last = lines[lines.length - 1];\n      if (last === undefined || value - last >= SNAP) lines.push(value);\n    });\n  return lines;\n}\n\n/** The index of the line a boundary snapped to: the last line not after it. */\nfunction lineIndex(lines: number[], value: number): number {\n  let found = 0;\n  lines.forEach((line, index) => {\n    if (line <= value + 1e-9) found = index;\n  });\n  return found;\n}\n\nfunction spans(lines: number[], from: number, to: number): [number, number] {\n  const start = lineIndex(lines, from);\n  return [start, Math.max(start + 1, lineIndex(lines, to))];\n}\n\nfunction tracks(lines: number[]): number[] {\n  return lines.slice(1).map((line, index) => round4(line - itemAt(lines, index)));\n}\n\n/**\n * The grid a layout is drawn on: every group's rectangle in percent of the root, cut into\n * content columns and rows at the distinct boundaries (closer than 0.05 percent snap together).\n * Pure numbers, so the server and the client draw the same tracks.\n */\nexport function computeTabGroupsGrid(layout: TabGroupsLayout): TabGroupsGrid {\n  const placed: { group: TabGroupsGroup; rect: Rect }[] = [];\n  const cuts: { split: TabGroupsSplit; index: number; position: number; rect: Rect }[] = [];\n  walkRects(\n    layout.root,\n    ROOT_RECT,\n    (group, rect) => placed.push({ group, rect }),\n    (split, index, position, rect) => cuts.push({ split, index, position, rect })\n  );\n  const xs = snapLines(placed.flatMap(({ rect }) => [rect.x0, rect.x1]));\n  const ys = snapLines(placed.flatMap(({ rect }) => [rect.y0, rect.y1]));\n  const columns = tracks(xs);\n  const rows = tracks(ys);\n  return {\n    columns,\n    rows,\n    groups: placed.map(({ group, rect }) => ({\n      id: group.id,\n      column: spans(xs, rect.x0, rect.x1),\n      row: spans(ys, rect.y0, rect.y1),\n    })),\n    separators: cuts.map(({ split, index, position, rect }) => {\n      const vertical = split.direction === \"row\";\n      const count = vertical ? columns.length : rows.length;\n      return {\n        split: split.id,\n        index,\n        orientation: vertical ? \"vertical\" : \"horizontal\",\n        line: clamp(lineIndex(vertical ? xs : ys, position), 1, Math.max(1, count - 1)),\n        span: vertical ? spans(ys, rect.y0, rect.y1) : spans(xs, rect.x0, rect.x1),\n      };\n    }),\n  };\n}\n\nconst SEPARATOR_TRACK = \" var(--smwb-tab-groups-separator-size) \";\n\n/** `grid-template-columns`: a `minmax(0, <w>fr)` per content column, separator tracks between. */\nexport function gridTemplateColumns(grid: TabGroupsGrid): string {\n  return grid.columns.map((width) => `minmax(0, ${width}fr)`).join(SEPARATOR_TRACK);\n}\n\n/** `grid-template-rows`: per content row an `auto` header track and a `minmax(0, <h>fr)` body track, separators between. */\nexport function gridTemplateRows(grid: TabGroupsGrid): string {\n  return grid.rows.map((height) => `auto minmax(0, ${height}fr)`).join(SEPARATOR_TRACK);\n}\n\n/** The `grid-area` of a group's header (its tab row). */\nexport function groupHeaderArea(group: TabGroupsGrid[\"groups\"][number]): string {\n  const [a, b] = group.column;\n  const [c] = group.row;\n  return `${3 * c + 1} / ${2 * a + 1} / ${3 * c + 2} / ${2 * b}`;\n}\n\n/** The `grid-area` of a group's panels. */\nexport function groupBodyArea(group: TabGroupsGrid[\"groups\"][number]): string {\n  const [a, b] = group.column;\n  const [c, d] = group.row;\n  return `${3 * c + 2} / ${2 * a + 1} / ${3 * d} / ${2 * b}`;\n}\n\n/** The `grid-area` of a separator. */\nexport function separatorArea(separator: TabGroupsGrid[\"separators\"][number]): string {\n  const k = separator.line;\n  const [from, to] = separator.span;\n  return separator.orientation === \"vertical\"\n    ? `${3 * from + 1} / ${2 * k} / ${3 * to} / ${2 * k + 1}`\n    : `${3 * k} / ${2 * from + 1} / ${3 * k + 1} / ${2 * to}`;\n}\n\n/**\n * The announcement of a change, read from the layout after it: \"Terminal moved to group 2 of 3\",\n * \"… to a new group on the right\", \"… to position 2 of 4\"; \"\" for select, activate, close and resize.\n */\nexport function describeTabGroupsChange(\n  change: TabGroupsChange,\n  layout: TabGroupsLayout,\n  title: (tabId: string) => string,\n  labels: TabGroupsLabels = TAB_GROUPS_LABELS\n): string {\n  if (change.type === \"split\") return labels.movedToNewGroup(title(change.tab), change.edge);\n  if (change.type !== \"move\") return \"\";\n  if (change.from === change.to) {\n    const group = getGroup(layout, change.to);\n    const position = group ? group.tabs.indexOf(change.tab) + 1 : 0;\n    return labels.movedInGroup(title(change.tab), position || change.index + 1, group?.tabs.length ?? 0);\n  }\n  const groups = getGroups(layout);\n  const index = groups.findIndex((group) => group.id === change.to);\n  return labels.movedToGroup(title(change.tab), index + 1, groups.length);\n}\n"],"names":["TAB_GROUPS_LAYOUT_VERSION","NEW_GROUP_PLACES","TAB_GROUPS_LABELS","index","count","tab","edge","position","SNAP","SUM_TOLERANCE","MIN_EXTENT","MAX_DEPTH","ZONE_TOLERANCE","itemAt","items","item","clamp","value","min","max","round4","sum","values","total","collectGroups","node","out","child","firstGroup","lastGroup","forEachNode","visit","findPath","id","path","found","nodeAt","root","replaceAt","replacement","split","rest","children","getGroup","layout","groupId","getGroups","group","replaceGroup","withRoot","activeGroup","resolveActiveGroup","before","wanted","exists","heir","adjacentGroup","nextId","prefix","match","normalize","changed","sizes","size","next","grandchild","inner","removeAt","parentPath","parent","_","i","detachTab","tabId","tabs","active","insertTab","select","insertBeside","targetId","splitId","direction","half","at","target","createTabGroupsLayout","options","unique","isRecord","readNode","raw","seen","depth","rawChildren","rawSizes","validSizes","scale","rawChild","pruneEmpty","keepDrawable","width","height","row","extent","floor","short","spare","share","assignIds","used","missing","counters","rebuild","parseTabGroupsLayout","parsed","pruned","groups","syncTabs","removeTab","findGroupOfTab","addTab","source","moved","reorderTab","selectTab","closed","setActiveGroup","from","last","to","moveTab","destination","moveTabInDirection","neighbour","neighbourGroup","extentAlong","leastShare","parts","part","fraction","resizeSplit","delta","first","second","pair","least","lowFirst","lowSecond","walkRects","rect","onGroup","onSeparator","start","offset","childRect","ROOT_RECT","groupRects","rects","own","entry","horizontal","best","bestOverlap","overlap","previous","dropZoneAt","x","y","edgeSize","px","py","distances","zone","nearest","distance","snapLines","lines","a","b","lineIndex","line","spans","tracks","computeTabGroupsGrid","placed","cuts","xs","ys","columns","rows","vertical","SEPARATOR_TRACK","gridTemplateColumns","grid","gridTemplateRows","groupHeaderArea","c","groupBodyArea","d","separatorArea","separator","k","describeTabGroupsChange","change","title","labels"],"mappings":"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"}