@n-uf/placement 26.11.8 → 26.11.10

package/dist/chunk-PJD5HKYX.js

@@ -0,0 +1,759 @@
+import {
+  rect
+} from "./chunk-QMTNB2C3.js";
+
+// src/panels/model.ts
+var SIDES = ["left", "right"];
+var EDGES = ["top", "bottom"];
+var BAND_SIZE = { min: 120, max: 480, natural: 200 };
+var IDENTITY_VIEW = { x: 0, y: 0, scale: 1 };
+var DEFAULT_PANELS_OPTIONS = {
+  giveWay: { order: "oldest", by: "used" },
+  floats: "clamp",
+  fold: "rail",
+  floatVisible: 48,
+  pagesMin: 320,
+  view: IDENTITY_VIEW,
+  bar: 28,
+  rail: 36,
+  segment: 36,
+  railInset: 4,
+  tabs: 28,
+  bands: {},
+  pagesMinHeight: 240,
+  reserve: {}
+};
+var FLOAT_HEIGHT = 360;
+var FLOAT_MIN = { width: 160, height: 120 };
+var without = (list, x) => list.filter((y) => y !== x);
+var withOnce = (list, x) => list.includes(x) ? [...list] : [...list, x];
+function whereIs(state, id) {
+  for (const side of SIDES) {
+    const index = state.sides[side].findIndex((c) => c.panels.includes(id));
+    if (index >= 0) return { kind: "column", side, index };
+  }
+  for (const edge of EDGES) {
+    const index = state.bands?.[edge]?.panels.indexOf(id) ?? -1;
+    if (index >= 0) return { kind: "band", edge, index };
+  }
+  const float2 = state.floats.find((f) => f.id === id);
+  return float2 ? { kind: "float", float: float2 } : { kind: "none" };
+}
+var tick = (state) => Object.values(state.clock).reduce((m, c) => Math.max(m, c.opened, c.used), 0) + 1;
+var bump = (state, id, opened) => {
+  const t = tick(state);
+  const was = state.clock[id] ?? { opened: 0, used: 0 };
+  return { ...state, clock: { ...state.clock, [id]: { opened: opened ? t : was.opened, used: t } } };
+};
+var defOf = (defs, id) => defs.find((d) => d.id === id);
+function floatSize(def) {
+  if (def?.float) return { min: def.float.min, natural: def.float.natural };
+  const width = Math.max(FLOAT_MIN.width, def?.width.natural ?? FLOAT_MIN.width);
+  return { min: FLOAT_MIN, natural: { width, height: FLOAT_HEIGHT } };
+}
+var bandSize = (def) => ({ ...def?.band ?? BAND_SIZE });
+function bandHeight(defs, band) {
+  if (!defs) return band.height;
+  const ds = band.panels.map((id) => bandSize(defOf(defs, id)));
+  const lo = Math.max(0, ...ds.map((d) => d.min));
+  const hi = Math.max(lo, Math.min(...ds.map((d) => d.max)));
+  return Math.min(Math.max(Number.isFinite(band.height) ? band.height : lo, lo), hi);
+}
+var withBand = (state, edge, band) => {
+  const { bands: _b, ...rest } = state;
+  const bands = { ...state.bands };
+  if (band && band.panels.length) bands[edge] = band;
+  else delete bands[edge];
+  return EDGES.some((e) => bands[e]) ? { ...rest, bands } : rest;
+};
+function ownWidth(defs, state, id) {
+  const def = defOf(defs, id);
+  const w = whereIs(state, id);
+  const lo = def?.width.min ?? 0;
+  const hi = Math.max(lo, def?.width.max ?? Infinity);
+  if (w.kind === "column") return Math.min(Math.max(state.sides[w.side][w.index].width, lo), hi);
+  return def?.width.natural ?? lo;
+}
+function createPanels(defs, start) {
+  const column = (ids) => {
+    const ds = ids.map((id) => defOf(defs, id));
+    const lo = Math.max(0, ...ds.map((d) => d?.width.min ?? 0));
+    const hi = Math.max(lo, Math.min(...ds.map((d) => d?.width.max ?? Infinity)));
+    const natural = Math.max(0, ...ds.map((d) => d?.width.natural ?? 0));
+    return { panels: [...ids], width: Math.min(Math.max(natural, lo), hi) };
+  };
+  const floats = (start.floats ?? []).map((f) => {
+    const n = floatSize(defOf(defs, f.id)).natural;
+    return { id: f.id, rect: { x: f.x, y: f.y, width: f.width ?? n.width, height: f.height ?? n.height }, ...f.pinned ? { pinned: true } : {} };
+  });
+  const sides = { left: (start.left ?? []).map(column), right: (start.right ?? []).map(column) };
+  const bands = {};
+  for (const edge of EDGES) {
+    const ids = start[edge] ?? [];
+    if (!ids.length) continue;
+    const natural = Math.max(0, ...ids.map((id) => bandSize(defOf(defs, id)).natural));
+    bands[edge] = { panels: [...ids], height: bandHeight(defs, { panels: ids, height: natural }) };
+  }
+  const order = [...sides.left, ...sides.right].flatMap((c) => c.panels).concat(EDGES.flatMap((e) => bands[e]?.panels ?? [])).concat(floats.map((f) => f.id));
+  const clock = {};
+  order.forEach((id, i) => clock[id] = { opened: i + 1, used: i + 1 });
+  const s = { sides, floats, folded: [...start.folded ?? []], kept: [...start.kept ?? []], closed: [...start.closed ?? []], clock };
+  return EDGES.some((e) => bands[e]) ? { ...s, bands } : s;
+}
+function liftPanel(state, id) {
+  const out = (c) => {
+    const { active: _a, ...rest } = c;
+    return { ...c.active === id ? rest : c, panels: without(c.panels, id) };
+  };
+  const lift = (cols) => cols.map(out).filter((c) => c.panels.length > 0);
+  let s = { ...state, sides: { left: lift(state.sides.left), right: lift(state.sides.right) }, floats: state.floats.filter((f) => f.id !== id) };
+  for (const edge of EDGES) {
+    const b = s.bands?.[edge];
+    if (b?.panels.includes(id)) s = withBand(s, edge, { ...b, panels: without(b.panels, id) });
+  }
+  return s;
+}
+function open(state, id, at) {
+  let s = { ...state, closed: without(state.closed, id) };
+  if (at && whereIs(s, id).kind === "none") {
+    if ("edge" in at) {
+      const b = s.bands?.[at.edge];
+      const panels = [...b?.panels ?? [], id];
+      s = withBand({ ...s, folded: s.folded.filter((x) => !panels.includes(x)) }, at.edge, { panels, height: b?.height ?? at.height ?? BAND_SIZE.natural });
+    } else s = { ...s, sides: { ...s.sides, [at.side]: [...s.sides[at.side], { panels: [id], width: at.width }] } };
+  }
+  const w = whereIs(s, id);
+  if (w.kind === "column" && s.sides[w.side][w.index].show === "tabs") s = { ...s, sides: { ...s.sides, [w.side]: s.sides[w.side].map((c, i) => i === w.index ? { ...c, active: id } : c) } };
+  return bump(s, id, true);
+}
+var close = (state, id) => ({ ...state, closed: withOnce(state.closed, id), kept: without(state.kept, id) });
+function focus(state, id) {
+  const f = state.floats.find((x) => x.id === id);
+  const s = f ? { ...state, floats: [...state.floats.filter((x) => x !== f), f] } : state;
+  return bump(s, id, false);
+}
+function toggleFold(state, id) {
+  const w = whereIs(state, id);
+  if (w.kind === "band") {
+    const ids = state.bands[w.edge].panels;
+    const shown = ids.filter((x) => !state.closed.includes(x));
+    if ((shown.length ? shown : ids).every((x) => state.folded.includes(x))) return bump({ ...state, folded: state.folded.filter((x) => !ids.includes(x)) }, id, false);
+    return { ...state, folded: [...state.folded.filter((x) => !ids.includes(x)), ...ids] };
+  }
+  if (state.folded.includes(id)) return bump({ ...state, folded: without(state.folded, id) }, id, false);
+  return { ...state, folded: [...state.folded, id] };
+}
+function keep(state, id, on) {
+  if (!on) return { ...state, kept: without(state.kept, id) };
+  const k = whereIs(state, id).kind;
+  return k === "column" || k === "band" ? { ...state, kept: withOnce(state.kept, id) } : state;
+}
+function dockBand(state, id, edge, index, defs) {
+  const s = liftPanel(state, id);
+  const b = s.bands?.[edge];
+  const panels = [...b?.panels ?? []];
+  panels.splice(Math.max(0, Math.min(index, panels.length)), 0, id);
+  const height = b?.height ?? bandSize(defs ? defOf(defs, id) : void 0).natural;
+  const s1 = withBand(s, edge, { panels, height });
+  return bump({ ...s1, folded: s1.folded.filter((x) => !panels.includes(x)), closed: without(s1.closed, id) }, id, false);
+}
+function resizeBand(state, edge, height) {
+  const b = state.bands?.[edge];
+  if (!b || !Number.isFinite(height)) return state;
+  const t = tick(state);
+  const clock = { ...state.clock };
+  for (const id of b.panels) clock[id] = { opened: clock[id]?.opened ?? 0, used: t };
+  return { ...withBand(state, edge, { ...b, height: Math.max(0, height) }), clock };
+}
+function dock(state, id, side, index, options = {}) {
+  const w = whereIs(state, id);
+  const from = w.kind === "column" ? state.sides[w.side][w.index].width : 0;
+  const s = liftPanel(state, id);
+  const cols = [...s.sides[side]];
+  if (options.into && cols[index]) cols[index] = { ...cols[index], panels: [...cols[index].panels, id], ...cols[index].show === "tabs" ? { active: id } : {} };
+  else {
+    const at = Math.max(0, Math.min(index, cols.length));
+    cols.splice(at, 0, { panels: [id], width: options.width ?? from });
+  }
+  return bump({ ...s, sides: { ...s.sides, [side]: cols }, closed: without(s.closed, id) }, id, false);
+}
+function showTabs(state, side, index, on) {
+  const col = state.sides[side][index];
+  if (!col) return state;
+  const { show: _s, ...stack } = col;
+  return { ...state, sides: { ...state.sides, [side]: state.sides[side].map((c, i) => i === index ? on ? { ...col, show: "tabs" } : stack : c) } };
+}
+function activate(state, id) {
+  const w = whereIs(state, id);
+  if (w.kind !== "column") return state;
+  const sides = { ...state.sides, [w.side]: state.sides[w.side].map((c, i) => i === w.index ? { ...c, active: id } : c) };
+  return bump({ ...state, sides }, id, false);
+}
+function float(state, id, rect2, pinned) {
+  const was = state.floats.find((f2) => f2.id === id);
+  const on = pinned ?? !!was?.pinned;
+  const s = liftPanel(state, id);
+  const f = { id, rect: { ...rect2 }, ...on ? { pinned: true } : {} };
+  return bump({ ...s, floats: [...s.floats, f], kept: without(s.kept, id), closed: without(s.closed, id) }, id, false);
+}
+var toView = (r, v) => ({ ...r, x: v.x + r.x * v.scale, y: v.y + r.y * v.scale });
+var toPage = (r, v) => ({ ...r, x: (r.x - v.x) / v.scale, y: (r.y - v.y) / v.scale });
+function pin(state, id, on, view = IDENTITY_VIEW, shown) {
+  return {
+    ...state,
+    floats: state.floats.map((f) => {
+      if (f.id !== id || !!f.pinned === on) return f;
+      const seen = shown ? { ...f.rect, x: shown.x, y: shown.y } : f.pinned ? { ...f.rect } : toView(f.rect, view);
+      return on ? { id, rect: seen, pinned: true } : { id, rect: toPage(seen, view) };
+    })
+  };
+}
+function resizeColumn(state, side, index, width) {
+  const col = state.sides[side][index];
+  if (!col || !Number.isFinite(width)) return state;
+  const t = tick(state);
+  const clock = { ...state.clock };
+  for (const id of col.panels) clock[id] = { opened: clock[id]?.opened ?? 0, used: t };
+  return { ...state, sides: { ...state.sides, [side]: state.sides[side].map((c, i) => i === index ? { ...c, width: Math.max(0, width) } : c) }, clock };
+}
+function resizeFloat(state, id, rect2) {
+  if (!state.floats.some((f) => f.id === id)) return state;
+  return bump({ ...state, floats: state.floats.map((f) => f.id === id ? { ...f, rect: { ...rect2 } } : f) }, id, false);
+}
+function columnWidth(defs, col) {
+  if (!defs) return col.width;
+  const ds = col.panels.map((id) => defOf(defs, id));
+  const lo = Math.max(0, ...ds.map((d) => d?.width.min ?? 0));
+  const hi = Math.max(lo, Math.min(...ds.map((d) => d?.width.max ?? Infinity)));
+  return Math.min(Math.max(Number.isFinite(col.width) ? col.width : lo, lo), hi);
+}
+function samePlaces(a, b, defs) {
+  const cols = (s) => SIDES.map(
+    (side) => s.sides[side].map((c) => `${c.panels.join(",")}@${Math.round(columnWidth(defs, c))}${c.show === "tabs" ? `/tabs:${c.active ?? c.panels[0]}` : ""}`).join("|")
+  ).join("\u2016");
+  const fl = (s) => s.floats.map((f) => `${f.id}@${Math.round(f.rect.x)},${Math.round(f.rect.y)},${Math.round(f.rect.width)},${Math.round(f.rect.height)}${f.pinned ? "p" : ""}`).join("|");
+  const bs = (s) => EDGES.map((e) => {
+    const b2 = s.bands?.[e];
+    return b2 ? `${b2.panels.join(",")}@${Math.round(bandHeight(defs, b2))}` : "";
+  }).join("\u2016");
+  const set = (l) => [...l].sort().join(",");
+  return cols(a) === cols(b) && bs(a) === bs(b) && fl(a) === fl(b) && set(a.folded) === set(b.folded) && set(a.kept) === set(b.kept) && set(a.closed) === set(b.closed);
+}
+
+// src/panels/layout.ts
+var clamp = (v, lo, hi) => Math.min(Math.max(v, lo), Math.max(lo, hi));
+function giveWayOrder(cols, order) {
+  return [...cols].sort((a, b) => Number(a.kept) - Number(b.kept) || (order === "oldest" ? a.age - b.age : b.age - a.age) || a.index - b.index || SIDES.indexOf(a.side) - SIDES.indexOf(b.side));
+}
+function layoutPanels(defs, state, stage, options = {}) {
+  const opt = { ...DEFAULT_PANELS_OPTIONS, ...options };
+  const W = stage.width;
+  const H = stage.height;
+  const closed = new Set(state.closed);
+  const folded = new Set(state.folded);
+  const kept = new Set(state.kept);
+  const by = opt.giveWay.by;
+  const ride = opt.fold === "ride";
+  const px = (v) => typeof v === "number" && Number.isFinite(v) ? Math.max(0, v) : 0;
+  const reserveOpt = opt.reserve ?? {};
+  const bandOpts = opt.bands ?? {};
+  const minH = typeof opt.pagesMinHeight === "number" ? opt.pagesMinHeight : DEFAULT_PANELS_OPTIONS.pagesMinHeight;
+  const res = { top: px(reserveOpt.top), right: px(reserveOpt.right), bottom: px(reserveOpt.bottom), left: px(reserveOpt.left) };
+  const bandsIn = [];
+  const offNotes = [];
+  for (const edge of EDGES) {
+    const b = state.bands?.[edge];
+    if (!b) continue;
+    const panels = b.panels.filter((id) => !closed.has(id));
+    if (panels.length === 0) continue;
+    const o = bandOpts[edge];
+    if (!o) {
+      offNotes.push({ code: "band-off", edge, items: panels });
+      continue;
+    }
+    const ds = panels.map((id) => bandSize(defOf(defs, id)));
+    const min = Math.max(0, ...ds.map((d) => d.min));
+    const max = Math.max(min, Math.min(...ds.map((d) => d.max)));
+    const height = clamp(Number.isFinite(b.height) ? b.height : min, min, max);
+    const age = Math.max(...panels.map((id) => state.clock[id]?.[by] ?? 0));
+    bandsIn.push({ edge, panels, at: panels.map((id) => b.panels.indexOf(id)), min, max, height, hand: panels.every((id) => folded.has(id)), kept: panels.some((id) => kept.has(id)), age, mode: o.mode, span: o.span });
+  }
+  const bOrder = bandsIn.filter((b) => !b.hand).sort((a, b) => Number(a.kept) - Number(b.kept) || (opt.giveWay.order === "oldest" ? a.age - b.age : b.age - a.age) || EDGES.indexOf(b.edge) - EDGES.indexOf(a.edge));
+  const gh = { auto: /* @__PURE__ */ new Set(), heights: /* @__PURE__ */ new Map() };
+  const fitH = (list, room) => {
+    const order2 = bOrder.filter((b) => list.includes(b));
+    const hands = list.length - order2.length;
+    const fit2 = (k) => {
+      const auto = new Set(order2.slice(0, k));
+      const heights = new Map(order2.filter((b) => !auto.has(b)).map((b) => [b, b.height]));
+      let excess = [...heights.values()].reduce((a, b) => a + b, 0) + (hands + auto.size) * opt.bar - room;
+      for (const b of order2) {
+        if (excess <= 0 || auto.has(b)) continue;
+        const take = Math.min(excess, b.height - b.min);
+        if (take > 0) {
+          heights.set(b, b.height - take);
+          excess -= take;
+        }
+      }
+      return { auto, heights, excess };
+    };
+    let g2 = fit2(0);
+    for (let k = 1; g2.excess > 0 && k <= order2.length; k++) g2 = fit2(k);
+    for (const b of g2.auto) gh.auto.add(b);
+    for (const [b, h] of g2.heights) gh.heights.set(b, h);
+  };
+  const reservedIn = bandsIn.filter((b) => b.mode === "reserved");
+  const overlayIn = bandsIn.filter((b) => b.mode === "overlay");
+  fitH(reservedIn, H - res.top - res.bottom - Math.max(minH, overlayIn.length * opt.bar));
+  const bandH = (b) => b ? gh.heights.get(b) ?? opt.bar : 0;
+  const pagesH = H - res.top - res.bottom - reservedIn.reduce((a, b) => a + bandH(b), 0);
+  fitH(overlayIn, pagesH - minH);
+  const topB = bandsIn.find((b) => b.edge === "top");
+  const botB = bandsIn.find((b) => b.edge === "bottom");
+  const hT = bandH(topB);
+  const hB = bandH(botB);
+  const colTop = topB?.span === "full" ? (topB.mode === "overlay" ? res.top : 0) + hT : 0;
+  const colBot = botB?.span === "full" ? H - (botB.mode === "overlay" ? res.bottom : 0) - hB : H;
+  const CH = Math.max(0, colBot - colTop);
+  const cols = [];
+  for (const side of SIDES) {
+    state.sides[side].forEach((c, index) => {
+      const panels = c.panels.filter((id) => !closed.has(id));
+      if (panels.length === 0) return;
+      const ds = panels.map((id) => defOf(defs, id));
+      const min = Math.max(0, ...ds.map((d) => d?.width.min ?? 0));
+      const max = Math.max(min, Math.min(...ds.map((d) => d?.width.max ?? Infinity)));
+      const width = clamp(Number.isFinite(c.width) ? c.width : min, min, max);
+      const age = Math.max(...panels.map((id) => state.clock[id]?.[by] ?? 0));
+      const tabs = c.show === "tabs" ? { show: "tabs", active: c.active !== void 0 && panels.includes(c.active) ? c.active : panels[0] } : {};
+      cols.push({ side, index, panels, min, max, width, hand: panels.every((id) => folded.has(id)), kept: panels.some((id) => kept.has(id)), age, ...tabs });
+    });
+  }
+  const sectionHeights = (c, room) => {
+    const out = /* @__PURE__ */ new Map();
+    const open0 = c.panels.filter((id) => !folded.has(id));
+    const hOf = (id) => defOf(defs, id)?.height;
+    const auto = /* @__PURE__ */ new Set();
+    if (open0.some((id) => hOf(id))) {
+      const last = open0.at(-1);
+      const minOf = (id) => hOf(id)?.min ?? opt.bar;
+      const fits = () => (c.panels.length - open0.length + auto.size) * opt.bar + open0.filter((id) => !auto.has(id)).reduce((a, id) => a + minOf(id), 0) <= room;
+      const rank = (ids) => [...ids].sort((a, b) => {
+        const age = (id) => state.clock[id]?.[by] ?? 0;
+        return Number(kept.has(a)) - Number(kept.has(b)) || (opt.giveWay.order === "oldest" ? age(a) - age(b) : age(b) - age(a)) || c.panels.indexOf(a) - c.panels.indexOf(b);
+      });
+      for (const id of rank(open0.filter((x) => x !== last))) {
+        if (fits()) break;
+        if (minOf(id) > opt.bar) auto.add(id);
+      }
+      const open2 = open0.filter((id) => !auto.has(id));
+      const space = room - (c.panels.length - open2.length) * opt.bar;
+      const fixed = open2.filter((id) => id !== last && hOf(id));
+      const sharers = open2.filter((id) => id === last || !hOf(id));
+      const h = new Map(fixed.map((id) => [id, hOf(id).natural]));
+      let rest = space - fixed.reduce((a, id) => a + h.get(id), 0);
+      const need = sharers.reduce((a, id) => a + minOf(id), 0);
+      for (const id of rank(fixed)) {
+        if (rest >= need) break;
+        const take = Math.min(need - rest, h.get(id) - minOf(id));
+        h.set(id, h.get(id) - take);
+        rest += take;
+      }
+      if (rest >= need) {
+        let pool = [...sharers];
+        let left = rest;
+        for (; ; ) {
+          const share2 = left / pool.length;
+          const under = pool.filter((id) => minOf(id) > share2);
+          if (under.length === 0) {
+            for (const id of pool) h.set(id, share2);
+            break;
+          }
+          for (const id of under) h.set(id, minOf(id));
+          left -= under.reduce((a, id) => a + minOf(id), 0);
+          pool = pool.filter((id) => !under.includes(id));
+        }
+      } else {
+        const lastH = Math.max(0, Math.min(minOf(last), rest));
+        for (const id of sharers) h.set(id, id === last ? lastH : Math.max(0, rest - lastH) / (sharers.length - 1));
+      }
+      for (const id of c.panels) out.set(id, folded.has(id) ? { height: opt.bar, folded: "hand" } : auto.has(id) ? { height: opt.bar, folded: "auto" } : { height: Math.max(0, h.get(id)), folded: null });
+      return out;
+    }
+    const bars = c.panels.length - open0.length;
+    const share = Math.max(0, (room - bars * opt.bar) / open0.length);
+    for (const id of c.panels) out.set(id, folded.has(id) ? { height: opt.bar, folded: "hand" } : { height: share, folded: null });
+    return out;
+  };
+  const order = giveWayOrder(
+    cols.filter((c) => !c.hand),
+    opt.giveWay.order
+  );
+  const fit = (k) => {
+    const auto = new Set(order.slice(0, k));
+    const open2 = (side) => cols.some((c) => c.side === side && !c.hand && !auto.has(c));
+    const railed = (side) => cols.some((c) => c.side === side && (auto.has(c) || c.hand && !(ride && open2(side))));
+    const widths = new Map(order.filter((c) => !auto.has(c)).map((c) => [c, c.width]));
+    let excess = [...widths.values()].reduce((a, b) => a + b, 0) + SIDES.filter(railed).length * opt.rail + opt.pagesMin + res.left + res.right - W;
+    for (const c of order) {
+      if (excess <= 0 || auto.has(c)) continue;
+      const take = Math.min(excess, c.width - c.min);
+      if (take > 0) {
+        widths.set(c, c.width - take);
+        excess -= take;
+      }
+    }
+    return { auto, widths, excess };
+  };
+  let g = fit(0);
+  for (let k = 1; g.excess > 0 && k <= order.length; k++) g = fit(k);
+  const notes = [];
+  for (const c of order) {
+    const w = g.widths.get(c);
+    if (w !== void 0 && w < c.width) notes.push({ code: "column-shrunk", side: c.side, column: c.index, items: c.panels, from: c.width, to: w });
+  }
+  for (const c of order) if (g.auto.has(c)) notes.push({ code: c.kept ? "kept-folded" : "column-folded", side: c.side, column: c.index, items: c.panels });
+  const items = /* @__PURE__ */ new Map();
+  const placedCols = [];
+  const rails = {};
+  let x0 = 0;
+  let x1 = W;
+  for (const side of SIDES) {
+    const mine = cols.filter((c) => c.side === side);
+    const open2 = mine.filter((c) => !c.hand && !g.auto.has(c));
+    const host = ride ? open2[0] : void 0;
+    const riders = host ? mine.filter((c) => c.hand) : [];
+    const inRail = mine.filter((c) => c.hand && !riders.includes(c) || g.auto.has(c));
+    if (inRail.length) {
+      const r = side === "left" ? rect(0, colTop, opt.rail, CH) : rect(W - opt.rail, colTop, opt.rail, CH);
+      const segments = inRail.flatMap((c) => c.panels).map((id, i) => ({ id, rect: rect(r.x, colTop + opt.railInset + i * opt.segment, opt.rail, opt.segment) }));
+      rails[side] = { side, rect: r, segments };
+      for (const s of segments) {
+        const c = inRail.find((x) => x.panels.includes(s.id));
+        items.set(s.id, { rect: s.rect, kind: "segment", layer: 0, hidden: true, folded: c.hand ? "hand" : "auto", kept: kept.has(s.id), pinned: false, floating: false, side, column: c.index });
+      }
+      if (side === "left") x0 = opt.rail;
+      else x1 = W - opt.rail;
+    }
+    const at = /* @__PURE__ */ new Map();
+    for (const c of mine) {
+      const w = g.widths.get(c);
+      if (w === void 0 || riders.includes(c)) continue;
+      if (side === "left") {
+        at.set(c, rect(x0, colTop, w, CH));
+        x0 += w;
+      } else {
+        x1 -= w;
+        at.set(c, rect(x1, colTop, w, CH));
+      }
+    }
+    const riding = riders.flatMap((c) => c.panels.map((id) => ({ id, c })));
+    const top = riding.length * opt.bar;
+    for (const c of mine) {
+      const w = g.widths.get(c);
+      const folded1 = c.hand ? "hand" : g.auto.has(c) ? "auto" : null;
+      const base = { side, index: c.index, width: c.width, min: c.min, max: c.max, folded: folded1, kept: c.kept, panels: c.panels };
+      if (riders.includes(c)) {
+        const hr = at.get(host);
+        const first = riding.findIndex((x) => x.c === c);
+        c.panels.forEach(
+          (id, i) => items.set(id, { rect: rect(hr.x, colTop + (first + i) * opt.bar, hr.width, opt.bar), kind: "bar", layer: 0, hidden: false, folded: "hand", kept: kept.has(id), pinned: false, floating: false, side, column: c.index, rides: host.index })
+        );
+        placedCols.push({ ...base, rect: rect(hr.x, colTop + first * opt.bar, hr.width, c.panels.length * opt.bar), shrunk: false, rides: host.index });
+        continue;
+      }
+      const r = at.get(c) ?? rect(side === "left" ? x0 : x1, colTop, 0, CH);
+      const y0 = colTop + (c === host ? top : 0);
+      const tabbed = c.show === "tabs";
+      const strip = rect(r.x, y0, r.width, opt.tabs);
+      const shown = tabbed && w !== void 0 ? { strip, active: c.active } : {};
+      placedCols.push({ ...base, rect: r, shrunk: w !== void 0 && w < c.width, ...tabbed ? { show: "tabs" } : {}, ...shown });
+      if (w === void 0) continue;
+      const panel = (id, to, kind, f, more = {}) => {
+        items.set(id, { rect: to, kind, layer: 0, hidden: more.hidden ?? false, folded: f, kept: kept.has(id), pinned: false, floating: false, side, column: c.index, ...more.tab ? { tab: more.tab } : {} });
+      };
+      if (tabbed) {
+        const body = rect(r.x, y0 + opt.tabs, r.width, Math.max(0, colBot - y0 - opt.tabs));
+        const shade = folded.has(c.active);
+        const tw = r.width / c.panels.length;
+        c.panels.forEach((id, i) => {
+          const tab = rect(r.x + i * tw, y0, tw, opt.tabs);
+          if (id === c.active) panel(id, shade ? strip : body, shade ? "bar" : "column", shade ? "hand" : null, { tab });
+          else panel(id, body, "column", folded.has(id) ? "hand" : null, { tab, hidden: true });
+        });
+        continue;
+      }
+      const hs = sectionHeights(c, colBot - y0);
+      let y = y0;
+      for (const id of c.panels) {
+        const s = hs.get(id);
+        panel(id, rect(r.x, y, r.width, s.height), s.folded ? "bar" : "column", s.folded);
+        y += s.height;
+      }
+      for (const id of c.panels) if (hs.get(id).folded === "auto") notes.push({ code: "section-folded", side, column: c.index, items: [id] });
+    }
+  }
+  for (const b of bOrder) {
+    const h = gh.heights.get(b);
+    if (h !== void 0 && h < b.height) notes.push({ code: "band-shrunk", edge: b.edge, items: b.panels, from: b.height, to: h });
+  }
+  for (const b of bOrder) if (gh.auto.has(b)) notes.push({ code: b.kept ? "kept-folded" : "band-folded", edge: b.edge, items: b.panels });
+  const pw = Math.max(0, x1 - x0);
+  const pTop = topB?.mode === "reserved" ? hT : 0;
+  const pBot = botB?.mode === "reserved" ? H - hB : H;
+  const reserved = {};
+  const iTop = pTop + res.top + (topB?.mode === "overlay" ? hT : 0);
+  const iBot = pBot - res.bottom - (botB?.mode === "overlay" ? hB : 0);
+  if (res.top > 0) reserved.top = rect(x0, pTop, pw, res.top);
+  if (res.right > 0) reserved.right = rect(x0 + pw - res.right, iTop, res.right, Math.max(0, iBot - iTop));
+  if (res.bottom > 0) reserved.bottom = rect(x0, pBot - res.bottom, pw, res.bottom);
+  if (res.left > 0) reserved.left = rect(x0, iTop, res.left, Math.max(0, iBot - iTop));
+  const pages = rect(x0 + res.left, pTop + res.top, Math.max(0, pw - res.left - res.right), Math.max(0, pBot - res.bottom - pTop - res.top));
+  if (pages.width < opt.pagesMin) notes.push({ code: "pages-under-min", width: pages.width, min: opt.pagesMin });
+  if ((bandsIn.length || res.top + res.bottom > 0) && pages.height < minH - 1e-9) notes.push({ code: "pages-short", height: pages.height, min: minH });
+  const bands = {};
+  for (const b of bandsIn) {
+    const h = bandH(b);
+    const full = b.span === "full";
+    const over = b.mode === "overlay";
+    const y = b.edge === "top" ? over ? res.top : 0 : over ? H - res.bottom - h : H - h;
+    const r = full ? rect(0, y, W, h) : rect(x0, y, pw, h);
+    const f = b.hand ? "hand" : gh.auto.has(b) ? "auto" : null;
+    const hh = gh.heights.get(b);
+    bands[b.edge] = { edge: b.edge, rect: r, height: b.height, min: b.min, max: b.max, folded: f, shrunk: hh !== void 0 && hh < b.height, kept: b.kept, mode: b.mode, span: b.span, panels: b.panels };
+    const share = r.width / b.panels.length;
+    b.panels.forEach(
+      (id, i) => items.set(id, { rect: rect(r.x + i * share, r.y, share, h), kind: f ? "bar" : "band", layer: over ? 5 : 0, hidden: false, folded: f, kept: kept.has(id), pinned: false, floating: false, edge: b.edge, index: b.at[i] })
+    );
+  }
+  state.floats.forEach((f, i) => {
+    if (closed.has(f.id)) return;
+    const shaded = folded.has(f.id);
+    const at = shaded ? { ...f.rect, height: opt.bar } : f.rect;
+    const k = f.pinned ? 1 : opt.view.scale;
+    const r = { ...at };
+    if (opt.floats === "clamp") {
+      const lim = floatSize(defOf(defs, f.id)).min;
+      r.width = Math.max(lim.width, Math.min(r.width, W));
+      if (!shaded) r.height = Math.max(lim.height, Math.min(r.height, H));
+      if (r.width !== at.width || r.height !== at.height) notes.push({ code: "float-resized", items: [f.id] });
+      r.x = r.width <= W ? clamp(r.x, 0, (W - r.width) / k) : clamp(r.x, (opt.floatVisible - r.width) / k, (W - opt.floatVisible) / k);
+      r.y = r.height <= H ? clamp(r.y, 0, (H - r.height) / k) : clamp(r.y, 0, (H - opt.bar) / k);
+      if (r.x !== at.x || r.y !== at.y) notes.push({ code: "float-clamped", items: [f.id] });
+    }
+    const clamped = r.x !== at.x || r.y !== at.y || r.width !== at.width || r.height !== at.height;
+    items.set(f.id, {
+      rect: f.pinned ? r : toView(r, opt.view),
+      kind: shaded ? "bar" : "float",
+      layer: 10 + i,
+      hidden: false,
+      folded: shaded ? "hand" : null,
+      kept: false,
+      pinned: !!f.pinned,
+      floating: true,
+      ...clamped ? { clamped: true } : {}
+    });
+  });
+  notes.push(...offNotes);
+  return { items, columns: placedCols, rails, notes, pages, bands, reserved };
+}
+
+// src/panels/targets.ts
+var COLUMN_REACH = 22;
+var RAIL_EDGE = 10;
+function placeRank(place) {
+  switch (place.kind) {
+    case "float":
+      return 3e3;
+    case "band":
+      return (place.edge === "top" ? 2e3 : 2500) + Math.min(place.index, 499);
+    case "rail":
+      return place.side === "left" ? 0 : 1999;
+    case "column":
+      return place.side === "left" ? 1 + 2 * place.index : 1998 - 2 * place.index;
+    case "into":
+      return place.side === "left" ? 2 + 2 * place.index : 1997 - 2 * place.index;
+  }
+}
+function homePlace(state, id) {
+  const w = whereIs(state, id);
+  if (w.kind === "float") return { kind: "float" };
+  if (w.kind === "none") return null;
+  if (w.kind === "band") return { kind: "band", edge: w.edge, index: w.index };
+  return state.sides[w.side][w.index].panels.length === 1 ? { kind: "column", side: w.side, index: w.index } : { kind: "into", side: w.side, index: w.index };
+}
+var cut = (x0, x1, lo, hi) => [Math.max(x0, lo), Math.min(x1, hi)];
+function panelTargets(input) {
+  const { defs, state, id, stage } = input;
+  const opt = { ...DEFAULT_PANELS_OPTIONS, ...input.options };
+  const def = defOf(defs, id);
+  const s0 = liftPanel(state, id);
+  const l0 = layoutPanels(defs, s0, stage, opt);
+  const width = ownWidth(defs, state, id);
+  const W = stage.width;
+  const H = stage.height;
+  const R = COLUMN_REACH;
+  const bandOpts = opt.bands ?? {};
+  const reserve = opt.reserve ?? {};
+  const px = (v) => typeof v === "number" && Number.isFinite(v) ? Math.max(0, v) : 0;
+  const out = [];
+  const idOf = (place) => {
+    switch (place.kind) {
+      case "float":
+        return "float";
+      case "rail":
+        return `rail:${place.side}`;
+      case "band":
+        return s0.bands?.[place.edge] ? `band:${place.edge}:${place.index}` : `band:${place.edge}`;
+      default:
+        return `${place.kind}:${place.side}:${place.index}`;
+    }
+  };
+  const add = (place, priority, hit, make, free = false) => {
+    if (hit.width <= 0 || hit.height <= 0) return;
+    if (input.allows && !input.allows(id, place)) return;
+    if (place.kind !== "float" && samePlaces(make({ x: 0, y: 0 }, { x: 0, y: 0 }), state, defs)) return;
+    out.push({ id: idOf(place), priority, hit, panel: id, place, order: placeRank(place), make, ...free ? { free: true } : {} });
+  };
+  const fullTop = l0.bands.top?.span === "full" ? l0.bands.top.rect : null;
+  const fullBot = l0.bands.bottom?.span === "full" ? l0.bands.bottom.rect : null;
+  const top = fullTop ? fullTop.y + fullTop.height : 0;
+  const CH = Math.max(0, (fullBot ? fullBot.y : H) - top);
+  for (const side of SIDES) {
+    if (def?.sides && !def.sides.includes(side)) continue;
+    const left = side === "left";
+    const rail = l0.rails[side];
+    const edge = rail ? rail.rect.width : RAIL_EDGE;
+    const railHit = rail ? rail.rect : left ? rect(0, top, RAIL_EDGE, CH) : rect(W - RAIL_EDGE, top, RAIL_EDGE, CH);
+    add({ kind: "rail", side }, 1, railHit, () => {
+      const s = dock(state, id, side, 0, { width });
+      return { ...s, folded: [...s.folded.filter((x) => x !== id), id] };
+    });
+    const open2 = l0.columns.filter((c) => c.side === side && c.folded === null);
+    const lo = left ? edge : 0;
+    const hi = left ? W : W - edge;
+    const band = (x, outer, i) => {
+      const [a, b] = outer ? left ? cut(x, x + 2 * R, lo, hi) : cut(x - 2 * R, x, lo, hi) : cut(x - R, x + R, lo, hi);
+      add({ kind: "column", side, index: i }, 2, rect(a, top, b - a, CH), () => dock(state, id, side, i, { width }));
+    };
+    if (open2.length === 0) band(left ? l0.pages.x - px(reserve.left) : l0.pages.x + l0.pages.width + px(reserve.right), true, s0.sides[side].length);
+    open2.forEach((c, k) => {
+      band(left ? c.rect.x : c.rect.x + c.rect.width, k === 0, c.index);
+      add({ kind: "into", side, index: c.index }, 2, c.rect, () => dock(state, id, side, c.index, { into: true }));
+    });
+    const last = open2.at(-1);
+    if (last) band(left ? last.rect.x + last.rect.width : last.rect.x, false, last.index + 1);
+  }
+  const home = whereIs(state, id);
+  for (const e of EDGES) {
+    if (!bandOpts[e] || def?.sides && !def.sides.includes(e)) continue;
+    const pb = l0.bands[e];
+    const list = s0.bands?.[e]?.panels ?? [];
+    const make = (i) => () => dockBand(state, id, e, i, defs);
+    if (!pb) {
+      if (home.kind === "band" && home.edge === e && !s0.bands?.[e]) continue;
+      const p = l0.pages;
+      const h = Math.min(2 * opt.bar, p.height);
+      add({ kind: "band", edge: e, index: list.length }, 2, rect(p.x, e === "top" ? p.y : p.y + p.height - h, p.width, h), make(list.length));
+      continue;
+    }
+    const m = pb.panels.length;
+    const share = pb.rect.width / m;
+    for (let k = 0; k <= m; k++) {
+      const i = k < m ? list.indexOf(pb.panels[k]) : list.length;
+      const a = pb.rect.x + Math.max(0, k - 0.5) * share;
+      const b = pb.rect.x + Math.min(m, k + 0.5) * share;
+      add({ kind: "band", edge: e, index: i }, 2, rect(a, pb.rect.y, b - a, pb.rect.height), make(i));
+    }
+  }
+  if (def?.floats !== false) {
+    const was = state.floats.find((f) => f.id === id);
+    const size = was ? { width: was.rect.width, height: was.rect.height } : floatSize(def).natural;
+    const pinned = !!was?.pinned;
+    add(
+      { kind: "float" },
+      3,
+      rect(0, 0, W, H),
+      (p, grab) => {
+        const at = rect(p.x - grab.x, p.y - grab.y, size.width, size.height);
+        const s = float(state, id, pinned ? at : toPage(at, opt.view), pinned);
+        const laid = layoutPanels(defs, s, stage, opt).items.get(id).rect;
+        const shown = s.folded.includes(id) ? { ...laid, width: at.width, height: at.height } : laid;
+        return float(state, id, pinned ? shown : toPage(shown, opt.view), pinned);
+      },
+      true
+    );
+  }
+  return out.sort((a, b) => a.order - b.order);
+}
+function panelDrop(input, target, p, grab) {
+  const opt = { ...DEFAULT_PANELS_OPTIONS, ...input.options };
+  const state = target.make(p, grab);
+  const layout = layoutPanels(input.defs, state, input.stage, opt);
+  const placed = layout.items.get(input.id);
+  const key = target.free ? `float:${Math.round(placed.rect.x)},${Math.round(placed.rect.y)}` : target.id;
+  return { target: target.id, place: target.place, key, state, layout, slot: placed.rect, hidden: placed.hidden, free: !!target.free };
+}
+function panelStops(targets, options = {}) {
+  const stops = [];
+  for (const t of targets) {
+    if (t.place.kind === "float") {
+      if (!options.floats) continue;
+      const at = options.floats === true ? { x: t.hit.x + t.hit.width / 2, y: t.hit.y + t.hit.height / 2 } : options.floats.at;
+      const grab = options.floats === true ? { x: 0, y: 0 } : options.floats.grab ?? { x: 0, y: 0 };
+      stops.push({ id: t.id, place: t.place, state: t.make(at, grab), home: false, order: t.order });
+      continue;
+    }
+    stops.push({ id: t.id, place: t.place, state: t.make({ x: 0, y: 0 }, { x: 0, y: 0 }), home: false, order: t.order });
+  }
+  const h = options.home;
+  if (h) stops.push({ id: "home", place: h.place, state: h.state, home: true, order: placeRank(h.place) + (h.place.kind === "float" ? 1 : 0.5) });
+  return stops.sort((a, b) => a.order - b.order).map(({ order: _order, ...s }) => s);
+}
+
+export {
+  SIDES,
+  EDGES,
+  BAND_SIZE,
+  IDENTITY_VIEW,
+  DEFAULT_PANELS_OPTIONS,
+  FLOAT_HEIGHT,
+  FLOAT_MIN,
+  whereIs,
+  tick,
+  defOf,
+  floatSize,
+  bandSize,
+  bandHeight,
+  ownWidth,
+  createPanels,
+  liftPanel,
+  open,
+  close,
+  focus,
+  toggleFold,
+  keep,
+  dockBand,
+  resizeBand,
+  dock,
+  showTabs,
+  activate,
+  float,
+  toView,
+  toPage,
+  pin,
+  resizeColumn,
+  resizeFloat,
+  columnWidth,
+  samePlaces,
+  giveWayOrder,
+  layoutPanels,
+  COLUMN_REACH,
+  RAIL_EDGE,
+  placeRank,
+  homePlace,
+  panelTargets,
+  panelDrop,
+  panelStops
+};
+//# sourceMappingURL=chunk-PJD5HKYX.js.map