@n-uf/placement 26.11.10 → 26.11.12

package/dist/desk.js

@@ -1,4 +1,4 @@
-import "./chunk-7R5H2ABL.js";
+import "./chunk-2H3CSPEH.js";
 import {
   createPanels,
   floatSize,
@@ -6,7 +6,7 @@ import {
   panelDrop,
   panelTargets,
   showTabs
-} from "./chunk-PJD5HKYX.js";
+} from "./chunk-CJA6LRHN.js";
 import "./chunk-QMTNB2C3.js";
 
 // src/desk/index.ts

package/dist/panels.d.ts

@@ -1,6 +1,7 @@
-import { b as PanelsState, S as Side, E as Edge, C as Clock, a as PanelDef } from './targets-CLV69zMw.js';
-export { B as BAND_SIZE, g as Band, h as BandOption, i as COLUMN_REACH, j as Column, D as DEFAULT_PANELS_OPTIONS, k as DockOptions, m as EDGES, F as FLOAT_HEIGHT, n as FLOAT_MIN, o as FloatAt, G as GiveWay, I as IDENTITY_VIEW, e as PanelDrop, q as PanelKind, r as PanelPlace, s as PanelStop, t as PanelStopsOptions, d as PanelTarget, c as PanelTargetInput, f as PanelsLayout, u as PanelsNote, v as PanelsNoteCode, P as PanelsOptions, w as PanelsStart, x as Place, y as PlacedBand, z as PlacedColumn, A as PlacedPanel, H as PlacedRail, R as RAIL_EDGE, J as Reserve, K as ReserveEdge, L as SIDES, V as View, W as Where, M as activate, N as bandHeight, O as bandSize, Q as close, T as columnWidth, U as createPanels, X as defOf, Y as dock, Z as dockBand, _ as float, $ as floatSize, a0 as focus, a1 as giveWayOrder, a2 as homePlace, a3 as keep, l as layoutPanels, a4 as liftPanel, a5 as open, a6 as ownWidth, p as panelDrop, a7 as panelStops, a8 as panelTargets, a9 as pin, aa as placeRank, ab as resizeBand, ac as resizeColumn, ad as resizeFloat, ae as samePlaces, af as showTabs, ag as tick, ah as toPage, ai as toView, aj as toggleFold, ak as whereIs } from './targets-CLV69zMw.js';
+import { b as PanelsState, S as Side, E as Edge, C as Clock, a as PanelDef } from './targets-B6eLC-52.js';
+export { B as BAND_SIZE, g as Band, h as BandOption, i as COLUMN_REACH, j as Column, D as DEFAULT_PANELS_OPTIONS, k as DockOptions, m as EDGES, F as FLOAT_HEIGHT, n as FLOAT_MIN, o as FloatAt, G as GiveWay, I as IDENTITY_VIEW, e as PanelDrop, q as PanelKind, r as PanelPlace, s as PanelStop, t as PanelStopsOptions, d as PanelTarget, c as PanelTargetInput, f as PanelsLayout, u as PanelsNote, v as PanelsNoteCode, P as PanelsOptions, w as PanelsStart, x as Place, y as PlacedBand, z as PlacedColumn, A as PlacedPanel, H as PlacedRail, R as RAIL_EDGE, J as Reserve, K as ReserveEdge, L as SIDES, V as View, W as Where, M as activate, N as bandHeight, O as bandSize, Q as close, T as columnWidth, U as createPanels, X as defOf, Y as dock, Z as dockBand, _ as float, $ as floatSize, a0 as focus, a1 as giveWayOrder, a2 as homePlace, a3 as keep, l as layoutPanels, a4 as liftPanel, a5 as open, a6 as ownWidth, p as panelDrop, a7 as panelStops, a8 as panelTargets, a9 as pin, aa as placeRank, ab as resizeBand, ac as resizeColumn, ad as resizeFloat, ae as samePlaces, af as showTabs, ag as tick, ah as toPage, ai as toView, aj as toggleFold, ak as whereIs } from './targets-B6eLC-52.js';
 import { R as Rect } from './geometry-mL-GTRti.js';
+import './target-D3PiLg44.js';
 
 /**
  * The panels' stored form: `storePanels(state)` gives plain JSON-safe data (`{ v: 1, … }`); `readPanels(data, defs?)`

package/dist/panels.js

@@ -1,7 +1,7 @@
 import {
   readPanels,
   storePanels
-} from "./chunk-7R5H2ABL.js";
+} from "./chunk-2H3CSPEH.js";
 import {
   BAND_SIZE,
   COLUMN_REACH,
@@ -46,7 +46,7 @@ import {
   toView,
   toggleFold,
   whereIs
-} from "./chunk-PJD5HKYX.js";
+} from "./chunk-CJA6LRHN.js";
 import "./chunk-QMTNB2C3.js";
 export {
   BAND_SIZE,

package/dist/stack.d.ts

@@ -0,0 +1,237 @@
+import { R as Rect } from './geometry-mL-GTRti.js';
+import { T as Target } from './target-D3PiLg44.js';
+
+/**
+ * The edge stack's shapes. A stack is the items along one edge of a stage: a column (vertical, a side region) or a
+ * row (horizontal, a bar). An item is a panel or a control group; it declares its forms, largest first, and the
+ * solver (`fitStack`) picks one per item. Plain data in and out: no words, no time, no DOM.
+ *
+ * The form kinds are structural labels the app draws by; the solver reads only `menu` (a form with no room of its own)
+ * and, for the cross size, `open`. Panel and group kinds may be mixed on one item.
+ */
+
+/** `"column"` runs the stack down (its main size is a height, its cross size a width); `"row"` runs it across. */
+type StackAxis = "column" | "row";
+/** How a panel draws: open (header and body), a header only, a rail icon, or an entry in the » menu. */
+type PanelFormKind = "open" | "header" | "rail" | "menu";
+/** How a control group draws: a row of words, the words stacked, icons only, or an entry in the » menu. */
+type GroupFormKind = "row" | "stacked" | "icons" | "menu";
+type StackFormKind = PanelFormKind | GroupFormKind;
+/** Along the stack: `min` is the least it can be drawn, `natural` what it asks for; `grows` takes spare length. */
+interface MainSize {
+    readonly min: number;
+    readonly natural: number;
+    readonly grows?: boolean;
+}
+/** One way to draw an item. A `menu` form takes no room in the stack (the » entry stands for it). */
+interface StackForm {
+    readonly kind: StackFormKind;
+    readonly main: MainSize;
+    /**
+     * Across the stack: `natural` is what this form asks for (it sets the stack's cross size when `setsCross`); `min`
+     * is the least it can be drawn across (default `natural`). A form that doesn't set the cross size takes its next
+     * form only when its `min` is over the stack's cross size, so a header stays in a column an open panel made
+     * narrow when it has a small `min`.
+     */
+    readonly cross: {
+        readonly natural: number;
+        readonly min?: number;
+    };
+    /**
+     * Whether this form sets the stack's cross size (the column's width, the bar's height). Default: true for a
+     * panel's `open`, false for everything else (a group never sets a column's width).
+     */
+    readonly setsCross?: boolean;
+}
+interface StackItem {
+    readonly id: string;
+    /** Largest first. The solver starts at `from` and steps down one at a time. An item with none is left out. */
+    readonly forms: readonly StackForm[];
+    /** How recently it was used: the smaller, the longer ago, the sooner it gives way. */
+    readonly used: number;
+    /** Kept: gives way after every item that isn't. */
+    readonly kept?: boolean;
+    /**
+     * The first form the item may take, an index into `forms` (default 0; a panel folded by hand starts at its header).
+     * The solver never goes above it. `form` in the result and in the notes are indexes into `forms`, not into what is
+     * left after `from`.
+     */
+    readonly from?: number;
+}
+/** The cross size a stack may take. With no form setting it, the stack is a `rail` wide (default {@link DEFAULT_RAIL}). */
+interface CrossLimits {
+    readonly min: number;
+    readonly max: number;
+    readonly rail?: number;
+}
+interface StackInput {
+    readonly axis: StackAxis;
+    /** The stack's length along the axis. */
+    readonly length: number;
+    readonly cross: CrossLimits;
+    /** In order, from the start of the stack. */
+    readonly items: readonly StackItem[];
+    /** The » menu entry's size along the stack, taken only while an item is in the menu (default {@link DEFAULT_MENU}). */
+    readonly menu?: {
+        readonly main: number;
+    };
+}
+/** The width of a stack nothing open holds, px. */
+declare const DEFAULT_RAIL = 30;
+/** The » menu entry's size along the stack, px. */
+declare const DEFAULT_MENU = 28;
+/** Whether a form sets the stack's cross size: its own say, else true for a panel's `open`. */
+declare const formSetsCross: (f: StackForm) => boolean;
+/** `input` with `item` inserted at index `at` (clamped to the items' range). */
+declare function withItem(input: StackInput, item: StackItem, at: number): StackInput;
+/** An item drawn: the form it took, its kind and its rect (stack-local px). One in the menu has the menu entry's rect. */
+interface PlacedStackItem {
+    readonly id: string;
+    /** Index into the item's `forms`. */
+    readonly form: number;
+    readonly kind: StackFormKind;
+    readonly rect: Rect;
+}
+interface StackMenu {
+    /** The » entry's rect. */
+    readonly rect: Rect;
+    /** The items in it, in the stack's order: exactly the items whose kind is `menu`. */
+    readonly items: readonly string[];
+}
+/**
+ * Why a stack looks as it does:
+ * - `form-down`: an item took a smaller form than the one it started in (`from`, an index into its forms), by length
+ *   or by cross size.
+ * - `to-menu`: an item is in the » menu.
+ * - `too-wide`: an item's form doesn't set the cross size and its `cross.min` is over the stack's. Cross size never
+ *   puts an item in the menu, so it keeps its last drawn form and the app clips it.
+ * - `no-forms`: an item with no forms, left out of `items`.
+ * - `overflow`: no item can give more way and the stack is still `over` px too long (forms that don't end in a `menu`
+ *   form can't give more; neither can a stack where going into the menu would only make it longer).
+ */
+type StackNote = {
+    readonly code: "form-down";
+    readonly id: string;
+    readonly from: number;
+    readonly to: number;
+} | {
+    readonly code: "to-menu";
+    readonly id: string;
+} | {
+    readonly code: "too-wide";
+    readonly id: string;
+} | {
+    readonly code: "no-forms";
+    readonly id: string;
+} | {
+    readonly code: "overflow";
+    readonly over: number;
+};
+type StackNoteCode = StackNote["code"];
+interface StackFit {
+    readonly axis: StackAxis;
+    readonly length: number;
+    /** The stack's size across: the widest `open` (clamped to the limits), or the rail. */
+    readonly cross: number;
+    /** One per input item that has forms, in order. */
+    readonly items: readonly PlacedStackItem[];
+    /** The » entry, or null while no item is in the menu. */
+    readonly menu: StackMenu | null;
+    /** `no-forms` first, then `form-down` per item in the order they gave way, `to-menu`, `too-wide`, and `overflow`. */
+    readonly notes: readonly StackNote[];
+}
+
+declare function fitStack(input: StackInput): StackFit;
+
+/**
+ * The drop targets for dragging an item into a stack, in the shape @n-uf/motion/drag takes. `stackTargets(input,
+ * dragged)` gives one target for every gap of the stack without the dragged item (an item of the input with its id
+ * is lifted out first, so a reorder within a stack works): before each item and after the last, so an empty stack has
+ * one. An item with no forms has no place of its own, but its gaps count.
+ *
+ * - `id` `gap:<k>`, priority 2, `place` `{ kind: "gap", at: k }` (k counts the input's items, the dragged one lifted
+ *   out, including any with no forms; it is not an index into `fit.items`, which leaves those out: look the dragged
+ *   item up there by its id, as `slot` already does).
+ * - `hit`: the gap's zone along the axis, the stack split at its items' middles (an item in the menu has no place of
+ *   its own: the gaps next to it split the stretch where the stack's drawn items end; with every item in the menu only
+ *   the last gap, "at the end", has any length, and the others are a point at the start). Across, it is the larger of
+ *   the stack's current size and the size the drop gives it, so the pointer over the preview is over the target.
+ * - `fit`: the full `fitStack` of the stack with the dragged item inserted at k, and `input` the stack that was
+ *   solved. The preview is `slot`, the dragged item's rect in `fit`: exactly the rect it gets after the drop, because
+ *   the drop is that same solve. `marker` is the line where its leading edge lands: a rect with no thickness across
+ *   the stack's cross size (the app draws it with one).
+ *
+ * The dragged item counts as just used: it is newer than every item in the stack, so the others give way before it.
+ * A group lands in the form that fits; a panel that would set a wider column makes room by that solve too. A dragged
+ * item with no forms has no targets.
+ */
+
+type StackPlace = {
+    readonly kind: "gap";
+    readonly at: number;
+};
+interface StackTarget extends Target {
+    readonly priority: 2;
+    /** The item dragged. */
+    readonly item: string;
+    readonly place: StackPlace;
+    /** The line where the dragged item's leading edge lands. */
+    readonly marker: Rect;
+    /** The stack with the dragged item inserted: what a drop here makes. */
+    readonly input: StackInput;
+    /** Its fit: the preview and the drop are both its rect for the dragged item. */
+    readonly fit: StackFit;
+}
+declare function stackTargets(input: StackInput, dragged: StackItem): StackTarget[];
+
+/**
+ * The stack's stored form: `storeStack(state)` gives plain JSON-safe data (`{ v: 1, order, kept, closed, used, forms
+ * }`); `readStack(data, known?)` reads parsed data back and never throws. Anything but an object of version 1 is
+ * `{ ok: false, error }`. Inside one it is lenient, as the panels' reader is: an id that isn't a string, is repeated
+ * or (with `known`) isn't one the consumer has is dropped and listed in `dropped`; a `kept`, `closed`, `used` or
+ * `forms` entry for an id that isn't in `order` is dropped; a form that isn't a whole number from 1 up is dropped;
+ * the key `__proto__` in `forms` is dropped (the other keys, `constructor` and `prototype` included, are ids like any
+ * other: `forms` is an object with no prototype, written and read); a field this version doesn't know is skipped and
+ * reported as `"<field>"`. An item the consumer has that the stored order lacks is no error: the consumer places it.
+ *
+ * - `kept`: items kept open (they give way last).
+ * - `closed`: items the user closed; their place in `order` is kept for when they open.
+ * - `used`: the use order, oldest to newest, so a reload restores who gives way first (an item's `used` is its index in
+ *   it; one the list lacks is older than all). An id listed twice counts at its last place: the newest use wins.
+ * - `forms`: the user's chosen form per item, the index of the largest form it may take (`StackItem.from`). 0, the
+ *   first, is not stored.
+ */
+interface StackState {
+    /** The items' order along the stack. */
+    readonly order: readonly string[];
+    /** Items kept open: they give way last. */
+    readonly kept: readonly string[];
+    /** Items the user closed. */
+    readonly closed: readonly string[];
+    /** The use order, oldest first. */
+    readonly used: readonly string[];
+    /** The form index the user chose per item (only those that chose one; absent means the first). */
+    readonly forms: Readonly<Record<string, number>>;
+}
+interface StoredStack {
+    readonly v: 1;
+    readonly order: string[];
+    readonly kept: string[];
+    readonly closed: string[];
+    readonly used: string[];
+    readonly forms: Record<string, number>;
+}
+type StackRead = {
+    readonly ok: true;
+    readonly state: StackState;
+    readonly dropped: readonly string[];
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/** A state with these items in this order, none kept or closed, used in that order, every form the first. */
+declare const createStack: (order: readonly string[]) => StackState;
+declare function storeStack(state: StackState): StoredStack;
+declare function readStack(data: unknown, known?: readonly string[]): StackRead;
+
+export { type CrossLimits, DEFAULT_MENU, DEFAULT_RAIL, type GroupFormKind, type MainSize, type PanelFormKind, type PlacedStackItem, type StackAxis, type StackFit, type StackForm, type StackFormKind, type StackInput, type StackItem, type StackMenu, type StackNote, type StackNoteCode, type StackPlace, type StackRead, type StackState, type StackTarget, type StoredStack, createStack, fitStack, formSetsCross, readStack, stackTargets, storeStack, withItem };

package/dist/stack.js

@@ -0,0 +1,272 @@
+import {
+  rect
+} from "./chunk-QMTNB2C3.js";
+
+// src/stack/model.ts
+var DEFAULT_RAIL = 30;
+var DEFAULT_MENU = 28;
+var finite = (x, fallback) => Number.isFinite(x) ? x : fallback;
+function limitsOf(input) {
+  const min = Math.max(0, finite(input.cross.min, 0));
+  const max = Number.isNaN(input.cross.max) ? Infinity : input.cross.max;
+  return { min, max: Math.max(min, max), rail: Math.max(0, finite(input.cross.rail ?? DEFAULT_RAIL, DEFAULT_RAIL)) };
+}
+var menuMain = (input) => Math.max(0, finite(input.menu?.main ?? DEFAULT_MENU, DEFAULT_MENU));
+var formSetsCross = (f) => f.setsCross ?? f.kind === "open";
+function withItem(input, item, at) {
+  const k = Math.min(Math.max(0, Math.floor(at)), input.items.length);
+  return { ...input, items: [...input.items.slice(0, k), item, ...input.items.slice(k)] };
+}
+
+// src/stack/layout.ts
+var EPS = 1e-6;
+var isMenu = (f) => f.kind === "menu";
+var finite2 = (x, fallback = 0) => Number.isFinite(x) ? x : fallback;
+var mainOf = (f, which) => isMenu(f) ? 0 : Math.max(0, finite2(f.main[which]));
+var crossMin = (f) => finite2(f.cross.min ?? f.cross.natural);
+function victim(items, at) {
+  let best = -1;
+  for (let i = 0; i < items.length; i++) {
+    if (at[i] + 1 >= items[i].forms.length) continue;
+    if (best < 0) {
+      best = i;
+      continue;
+    }
+    const a = items[i];
+    const b = items[best];
+    const ka = a.kept ? 1 : 0;
+    const kb = b.kept ? 1 : 0;
+    if (ka !== kb ? ka < kb : a.used !== b.used ? a.used < b.used : true) best = i;
+  }
+  return best;
+}
+function fitStack(input) {
+  const length = Math.max(0, finite2(input.length));
+  const lim = limitsOf(input);
+  const items = input.items.filter((it) => it.forms.length > 0);
+  const start = items.map((it) => Math.min(Math.max(0, Math.floor(finite2(it.from ?? 0))), it.forms.length - 1));
+  const at = [...start];
+  const form = (i) => items[i].forms[at[i]];
+  const idx = items.map((_, i) => i);
+  const firstStep = [];
+  const menuOrder = [];
+  const step = (i) => {
+    if (!firstStep.includes(i)) firstStep.push(i);
+    at[i]++;
+    if (isMenu(form(i)) && !menuOrder.includes(i)) menuOrder.push(i);
+  };
+  for (const i of idx) if (isMenu(form(i))) menuOrder.push(i);
+  const crossOf = () => {
+    const setters = idx.filter((i) => !isMenu(form(i)) && formSetsCross(form(i)));
+    if (setters.length === 0) return lim.rail;
+    const want = Math.max(...setters.map((i) => finite2(form(i).cross.natural)));
+    return Math.min(Math.max(want, lim.min), lim.max);
+  };
+  const inMenu = () => idx.some((i) => isMenu(form(i)));
+  const minSum = () => idx.reduce((s, i) => s + mainOf(form(i), "min"), 0) + (inMenu() ? menuMain(input) : 0);
+  const canStep = (i) => at[i] + 1 < items[i].forms.length;
+  const tooWide = (i, cross2) => !isMenu(form(i)) && !formSetsCross(form(i)) && crossMin(form(i)) > cross2 + EPS;
+  let cross = crossOf();
+  let overflow = 0;
+  const guard = items.reduce((s, it) => s + it.forms.length, 0) + 1;
+  for (let n = 0; n <= guard; n++) {
+    cross = crossOf();
+    let stepped = false;
+    for (const i of idx) {
+      if (tooWide(i, cross) && canStep(i) && !isMenu(items[i].forms[at[i] + 1])) {
+        step(i);
+        stepped = true;
+      }
+    }
+    if (stepped) continue;
+    const over = minSum() - length;
+    if (over <= EPS) break;
+    const v = victim(items, at);
+    if (v < 0) {
+      overflow = over;
+      break;
+    }
+    const intoMenu = isMenu(items[v].forms[at[v] + 1]);
+    const gain = mainOf(form(v), "min") - (inMenu() ? 0 : menuMain(input));
+    if (intoMenu && gain < 0 && idx.filter(canStep).length === 1) {
+      overflow = over;
+      break;
+    }
+    step(v);
+  }
+  cross = crossOf();
+  const menuSize = inMenu() ? menuMain(input) : 0;
+  const avail = Math.max(0, length - menuSize);
+  const drawn = idx.filter((i) => !isMenu(form(i)));
+  const min = (i) => mainOf(form(i), "min");
+  const nat = (i) => Math.max(min(i), mainOf(form(i), "natural"));
+  const sumMin = drawn.reduce((s, i) => s + min(i), 0);
+  const sumNat = drawn.reduce((s, i) => s + nat(i), 0);
+  const size = /* @__PURE__ */ new Map();
+  if (sumNat <= avail + EPS) {
+    const growers = drawn.filter((i) => form(i).main.grows);
+    const spare = Math.max(0, avail - sumNat);
+    const weight = growers.reduce((s, i) => s + nat(i), 0);
+    for (const i of drawn) {
+      const share = growers.includes(i) ? weight > EPS ? nat(i) / weight : 1 / growers.length : 0;
+      size.set(i, nat(i) + spare * share);
+    }
+  } else {
+    const t = avail > sumMin && sumNat > sumMin ? (avail - sumMin) / (sumNat - sumMin) : 0;
+    for (const i of drawn) size.set(i, min(i) + (nat(i) - min(i)) * t);
+  }
+  const rectAt = (from, main) => input.axis === "column" ? { x: 0, y: from, width: cross, height: main } : { x: from, y: 0, width: main, height: cross };
+  const rects = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  for (const i of drawn) {
+    const s = size.get(i);
+    rects.set(i, rectAt(cursor, s));
+    cursor += s;
+  }
+  const menuRect = rectAt(Math.max(cursor, length - menuSize), menuSize);
+  const inside = idx.filter((i) => isMenu(form(i)));
+  const menu = inside.length > 0 ? { rect: menuRect, items: inside.map((i) => items[i].id) } : null;
+  const placed = idx.map((i) => ({ id: items[i].id, form: at[i], kind: form(i).kind, rect: isMenu(form(i)) ? menuRect : rects.get(i) }));
+  const notes = [];
+  for (const it of input.items) if (it.forms.length === 0) notes.push({ code: "no-forms", id: it.id });
+  for (const i of firstStep) if (at[i] > start[i]) notes.push({ code: "form-down", id: items[i].id, from: start[i], to: at[i] });
+  for (const i of menuOrder) if (isMenu(form(i))) notes.push({ code: "to-menu", id: items[i].id });
+  for (const i of idx) if (tooWide(i, cross)) notes.push({ code: "too-wide", id: items[i].id });
+  if (overflow > EPS) notes.push({ code: "overflow", over: overflow });
+  return { axis: input.axis, length, cross, items: placed, menu, notes };
+}
+
+// src/stack/targets.ts
+function bounds(input, fit) {
+  const column = input.axis === "column";
+  const start = (r) => column ? r.y : r.x;
+  const size = (r) => column ? r.height : r.width;
+  const placed = new Map(fit.items.map((p) => [p.id, p]));
+  const b = [0];
+  let end = 0;
+  for (const it of input.items) {
+    const p = placed.get(it.id);
+    if (!p || p.kind === "menu") {
+      b.push(end);
+      continue;
+    }
+    b.push(start(p.rect) + size(p.rect) / 2);
+    end = start(p.rect) + size(p.rect);
+  }
+  b.push(fit.length);
+  for (let i = 1; i < b.length; i++) b[i] = Math.min(Math.max(b[i], b[i - 1]), fit.length);
+  return b;
+}
+function stackTargets(input, dragged) {
+  if (dragged.forms.length === 0) return [];
+  const rest = { ...input, items: input.items.filter((it) => it.id !== dragged.id) };
+  const base = fitStack(rest);
+  const b = bounds(rest, base);
+  const column = rest.axis === "column";
+  const newest = rest.items.reduce((m, it) => Math.max(m, it.used), dragged.used) + 1;
+  const item = { ...dragged, used: newest };
+  const out = [];
+  for (let k = 0; k <= rest.items.length; k++) {
+    const solved = withItem(rest, item, k);
+    const fit = fitStack(solved);
+    const slot = fit.items.find((p) => p.id === dragged.id).rect;
+    const from = b[k];
+    const to = b[k + 1];
+    const across = Math.max(base.cross, fit.cross);
+    out.push({
+      id: `gap:${k}`,
+      priority: 2,
+      item: dragged.id,
+      place: { kind: "gap", at: k },
+      hit: column ? rect(0, from, across, to - from) : rect(from, 0, to - from, across),
+      slot,
+      marker: column ? rect(slot.x, slot.y, slot.width, 0) : rect(slot.x, slot.y, 0, slot.height),
+      input: solved,
+      fit
+    });
+  }
+  return out;
+}
+
+// src/stack/store.ts
+var createStack = (order) => ({ order: [...order], kept: [], closed: [], used: [...order], forms: {} });
+var isForm = (f) => typeof f === "number" && Number.isInteger(f) && f >= 1;
+var uniq = (ids, order) => [...new Set(ids)].filter((id) => order.includes(id));
+var uniqLast = (ids, order) => ids.filter((id, i) => order.includes(id) && ids.lastIndexOf(id) === i);
+var noForms = () => /* @__PURE__ */ Object.create(null);
+function storeStack(state) {
+  const forms = noForms();
+  for (const id of state.order) {
+    const f = state.forms[id];
+    if (id !== "__proto__" && Object.hasOwn(state.forms, id) && isForm(f)) forms[id] = f;
+  }
+  return { v: 1, order: [...state.order], kept: uniq(state.kept, state.order), closed: uniq(state.closed, state.order), used: uniqLast(state.used, state.order), forms };
+}
+var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+function readStack(data, known) {
+  try {
+    return read(data, known);
+  } catch (e) {
+    return { ok: false, error: `unreadable: ${e instanceof Error ? e.message : typeof e}` };
+  }
+}
+var versionWords = (v) => typeof v === "number" ? String(v) : typeof v === "string" ? JSON.stringify(v.length > 24 ? `${v.slice(0, 24)}\u2026` : v) : typeof v;
+function read(data, known) {
+  if (!isObject(data)) return { ok: false, error: "not an object" };
+  if (data.v !== 1) return { ok: false, error: `unknown version ${versionWords(data.v)} (this reads version 1)` };
+  if (!Array.isArray(data.order)) return { ok: false, error: "order is missing" };
+  const dropped = [];
+  const drop = (what) => {
+    if (!dropped.includes(what)) dropped.push(what);
+  };
+  for (const k of Object.keys(data)) if (!["v", "order", "kept", "closed", "used", "forms"].includes(k)) drop(k);
+  const order = [];
+  for (const x of data.order) {
+    if (typeof x !== "string") drop(`a ${typeof x} where an id goes`);
+    else if (known && !known.includes(x) || order.includes(x)) drop(x);
+    else order.push(x);
+  }
+  const list = (key) => {
+    const out = [];
+    const x = data[key];
+    if (x === void 0) return out;
+    if (!Array.isArray(x)) {
+      drop(key);
+      return out;
+    }
+    for (const id of x) {
+      if (typeof id === "string" && order.includes(id)) {
+        if (key === "used" && out.includes(id)) out.splice(out.indexOf(id), 1);
+        if (!out.includes(id)) out.push(id);
+      } else drop(typeof id === "string" ? `${key}:${id}` : `a ${typeof id} in ${key}`);
+    }
+    return out;
+  };
+  const kept = list("kept");
+  const closed = list("closed");
+  const used = list("used");
+  const forms = noForms();
+  if (data.forms !== void 0) {
+    if (!isObject(data.forms)) drop("forms");
+    else {
+      for (const id of Object.keys(data.forms)) {
+        const f = data.forms[id];
+        if (id === "__proto__" || !Object.hasOwn(data.forms, id) || !order.includes(id) || !isForm(f)) drop(`forms:${id}`);
+        else forms[id] = f;
+      }
+    }
+  }
+  return { ok: true, state: { order, kept, closed, used, forms }, dropped };
+}
+export {
+  DEFAULT_MENU,
+  DEFAULT_RAIL,
+  createStack,
+  fitStack,
+  formSetsCross,
+  readStack,
+  stackTargets,
+  storeStack,
+  withItem
+};
+//# sourceMappingURL=stack.js.map

package/dist/stack.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/stack/model.ts","../src/stack/layout.ts","../src/stack/targets.ts","../src/stack/store.ts"],"sourcesContent":["/**\n * The edge stack's shapes. A stack is the items along one edge of a stage: a column (vertical, a side region) or a\n * row (horizontal, a bar). An item is a panel or a control group; it declares its forms, largest first, and the\n * solver (`fitStack`) picks one per item. Plain data in and out: no words, no time, no DOM.\n *\n * The form kinds are structural labels the app draws by; the solver reads only `menu` (a form with no room of its own)\n * and, for the cross size, `open`. Panel and group kinds may be mixed on one item.\n */\nimport type { Rect } from \"../geometry\";\n\n/** `\"column\"` runs the stack down (its main size is a height, its cross size a width); `\"row\"` runs it across. */\nexport type StackAxis = \"column\" | \"row\";\n\n/** How a panel draws: open (header and body), a header only, a rail icon, or an entry in the » menu. */\nexport type PanelFormKind = \"open\" | \"header\" | \"rail\" | \"menu\";\n/** How a control group draws: a row of words, the words stacked, icons only, or an entry in the » menu. */\nexport type GroupFormKind = \"row\" | \"stacked\" | \"icons\" | \"menu\";\nexport type StackFormKind = PanelFormKind | GroupFormKind;\n\n/** Along the stack: `min` is the least it can be drawn, `natural` what it asks for; `grows` takes spare length. */\nexport interface MainSize {\n  readonly min: number;\n  readonly natural: number;\n  readonly grows?: boolean;\n}\n\n/** One way to draw an item. A `menu` form takes no room in the stack (the » entry stands for it). */\nexport interface StackForm {\n  readonly kind: StackFormKind;\n  readonly main: MainSize;\n  /**\n   * Across the stack: `natural` is what this form asks for (it sets the stack's cross size when `setsCross`); `min`\n   * is the least it can be drawn across (default `natural`). A form that doesn't set the cross size takes its next\n   * form only when its `min` is over the stack's cross size, so a header stays in a column an open panel made\n   * narrow when it has a small `min`.\n   */\n  readonly cross: { readonly natural: number; readonly min?: number };\n  /**\n   * Whether this form sets the stack's cross size (the column's width, the bar's height). Default: true for a\n   * panel's `open`, false for everything else (a group never sets a column's width).\n   */\n  readonly setsCross?: boolean;\n}\n\nexport interface StackItem {\n  readonly id: string;\n  /** Largest first. The solver starts at `from` and steps down one at a time. An item with none is left out. */\n  readonly forms: readonly StackForm[];\n  /** How recently it was used: the smaller, the longer ago, the sooner it gives way. */\n  readonly used: number;\n  /** Kept: gives way after every item that isn't. */\n  readonly kept?: boolean;\n  /**\n   * The first form the item may take, an index into `forms` (default 0; a panel folded by hand starts at its header).\n   * The solver never goes above it. `form` in the result and in the notes are indexes into `forms`, not into what is\n   * left after `from`.\n   */\n  readonly from?: number;\n}\n\n/** The cross size a stack may take. With no form setting it, the stack is a `rail` wide (default {@link DEFAULT_RAIL}). */\nexport interface CrossLimits {\n  readonly min: number;\n  readonly max: number;\n  readonly rail?: number;\n}\n\nexport interface StackInput {\n  readonly axis: StackAxis;\n  /** The stack's length along the axis. */\n  readonly length: number;\n  readonly cross: CrossLimits;\n  /** In order, from the start of the stack. */\n  readonly items: readonly StackItem[];\n  /** The » menu entry's size along the stack, taken only while an item is in the menu (default {@link DEFAULT_MENU}). */\n  readonly menu?: { readonly main: number };\n}\n\n/** The width of a stack nothing open holds, px. */\nexport const DEFAULT_RAIL = 30;\n/** The » menu entry's size along the stack, px. */\nexport const DEFAULT_MENU = 28;\n\nconst finite = (x: number, fallback: number): number => (Number.isFinite(x) ? x : fallback);\n\n/**\n * The cross limits with a non-number replaced: `min` and `rail` that aren't finite become 0 and the default rail, a\n * `max` that is NaN becomes no limit (Infinity is one already), and `max` is never under `min`.\n */\nexport function limitsOf(input: StackInput): { readonly min: number; readonly max: number; readonly rail: number } {\n  const min = Math.max(0, finite(input.cross.min, 0));\n  const max = Number.isNaN(input.cross.max) ? Infinity : input.cross.max;\n  return { min, max: Math.max(min, max), rail: Math.max(0, finite(input.cross.rail ?? DEFAULT_RAIL, DEFAULT_RAIL)) };\n}\nexport const menuMain = (input: StackInput): number => Math.max(0, finite(input.menu?.main ?? DEFAULT_MENU, DEFAULT_MENU));\n\n/** Whether a form sets the stack's cross size: its own say, else true for a panel's `open`. */\nexport const formSetsCross = (f: StackForm): boolean => f.setsCross ?? f.kind === \"open\";\n\n/** `input` with `item` inserted at index `at` (clamped to the items' range). */\nexport function withItem(input: StackInput, item: StackItem, at: number): StackInput {\n  const k = Math.min(Math.max(0, Math.floor(at)), input.items.length);\n  return { ...input, items: [...input.items.slice(0, k), item, ...input.items.slice(k)] };\n}\n\n/** An item drawn: the form it took, its kind and its rect (stack-local px). One in the menu has the menu entry's rect. */\nexport interface PlacedStackItem {\n  readonly id: string;\n  /** Index into the item's `forms`. */\n  readonly form: number;\n  readonly kind: StackFormKind;\n  readonly rect: Rect;\n}\n\nexport interface StackMenu {\n  /** The » entry's rect. */\n  readonly rect: Rect;\n  /** The items in it, in the stack's order: exactly the items whose kind is `menu`. */\n  readonly items: readonly string[];\n}\n\n/**\n * Why a stack looks as it does:\n * - `form-down`: an item took a smaller form than the one it started in (`from`, an index into its forms), by length\n *   or by cross size.\n * - `to-menu`: an item is in the » menu.\n * - `too-wide`: an item's form doesn't set the cross size and its `cross.min` is over the stack's. Cross size never\n *   puts an item in the menu, so it keeps its last drawn form and the app clips it.\n * - `no-forms`: an item with no forms, left out of `items`.\n * - `overflow`: no item can give more way and the stack is still `over` px too long (forms that don't end in a `menu`\n *   form can't give more; neither can a stack where going into the menu would only make it longer).\n */\nexport type StackNote =\n  | { readonly code: \"form-down\"; readonly id: string; readonly from: number; readonly to: number }\n  | { readonly code: \"to-menu\"; readonly id: string }\n  | { readonly code: \"too-wide\"; readonly id: string }\n  | { readonly code: \"no-forms\"; readonly id: string }\n  | { readonly code: \"overflow\"; readonly over: number };\nexport type StackNoteCode = StackNote[\"code\"];\n\nexport interface StackFit {\n  readonly axis: StackAxis;\n  readonly length: number;\n  /** The stack's size across: the widest `open` (clamped to the limits), or the rail. */\n  readonly cross: number;\n  /** One per input item that has forms, in order. */\n  readonly items: readonly PlacedStackItem[];\n  /** The » entry, or null while no item is in the menu. */\n  readonly menu: StackMenu | null;\n  /** `no-forms` first, then `form-down` per item in the order they gave way, `to-menu`, `too-wide`, and `overflow`. */\n  readonly notes: readonly StackNote[];\n}\n","/**\n * `fitStack`: which form each item of a stack takes, and where it goes.\n *\n * 1. Every item starts in its largest form it may take (`forms[from]`, default the first).\n * 2. The stack's cross size is the largest `cross.natural` among the items whose form sets it (an open panel's, by\n *    default), clamped to the limits; with none, the rail width.\n * 3. Cross-fit: an item whose form doesn't set the cross size and whose `cross.min` is over it steps down until it\n *    fits (a group never sets a column's width, so a group alone becomes a rail of icons). Cross size never steps\n *    an item into the menu: when only the menu is left it keeps its last drawn form and a `too-wide` note says so.\n * 4. Give-way: while the smallest sizes (`main.min`) don't fit the length, the item used longest ago steps down one\n *    form; unkept before kept, the later in the stack first on a tie. The same item keeps giving way until its forms\n *    end, then the next does. A `menu` form takes no room; the » entry does, while any item is in it (and an item\n *    doesn't go into the menu when that would only make the stack longer and nothing else can give way).\n *    Steps 2 to 4 repeat until nothing changes: a panel folding can narrow the column, which asks more of the groups.\n * 5. The room the items leave goes to the forms that grow, shared by their natural sizes. With none, the items keep\n *    their natural sizes from the start of the stack. Between the minimum and natural sizes every item shrinks by the\n *    same share of what it can give.\n *\n * The solver has no open or closed state: it lays out the items it is given, and a consumer closes a panel by not\n * passing it (or by starting it at a later form with `from`). An item with no forms is left out (`no-forms`). Pure:\n * same input, same fit.\n */\nimport type { Rect } from \"../geometry\";\nimport { formSetsCross, limitsOf, menuMain, type PlacedStackItem, type StackFit, type StackForm, type StackInput, type StackItem, type StackMenu, type StackNote } from \"./model\";\n\nconst EPS = 1e-6;\nconst isMenu = (f: StackForm): boolean => f.kind === \"menu\";\nconst finite = (x: number, fallback = 0): number => (Number.isFinite(x) ? x : fallback);\nconst mainOf = (f: StackForm, which: \"min\" | \"natural\"): number => (isMenu(f) ? 0 : Math.max(0, finite(f.main[which])));\n/** The least a form can be drawn across the stack. */\nconst crossMin = (f: StackForm): number => finite(f.cross.min ?? f.cross.natural);\n\n/** The item that gives way next: unkept before kept, used longest ago, the later in the stack on a tie. */\nfunction victim(items: readonly StackItem[], at: readonly number[]): number {\n  let best = -1;\n  for (let i = 0; i < items.length; i++) {\n    if (at[i]! + 1 >= items[i]!.forms.length) continue;\n    if (best < 0) {\n      best = i;\n      continue;\n    }\n    const a = items[i]!;\n    const b = items[best]!;\n    const ka = a.kept ? 1 : 0;\n    const kb = b.kept ? 1 : 0;\n    if (ka !== kb ? ka < kb : a.used !== b.used ? a.used < b.used : true) best = i;\n  }\n  return best;\n}\n\nexport function fitStack(input: StackInput): StackFit {\n  const length = Math.max(0, finite(input.length));\n  const lim = limitsOf(input);\n  const items = input.items.filter((it) => it.forms.length > 0);\n  const start = items.map((it) => Math.min(Math.max(0, Math.floor(finite(it.from ?? 0))), it.forms.length - 1));\n  const at = [...start];\n  const form = (i: number): StackForm => items[i]!.forms[at[i]!]!;\n  const idx = items.map((_, i) => i);\n\n  const firstStep: number[] = [];\n  const menuOrder: number[] = [];\n  const step = (i: number): void => {\n    if (!firstStep.includes(i)) firstStep.push(i);\n    at[i]!++;\n    if (isMenu(form(i)) && !menuOrder.includes(i)) menuOrder.push(i);\n  };\n  // An item that starts in the menu is in it from the start.\n  for (const i of idx) if (isMenu(form(i))) menuOrder.push(i);\n\n  const crossOf = (): number => {\n    const setters = idx.filter((i) => !isMenu(form(i)) && formSetsCross(form(i)));\n    if (setters.length === 0) return lim.rail;\n    const want = Math.max(...setters.map((i) => finite(form(i).cross.natural)));\n    return Math.min(Math.max(want, lim.min), lim.max);\n  };\n  const inMenu = (): boolean => idx.some((i) => isMenu(form(i)));\n  const minSum = (): number => idx.reduce((s, i) => s + mainOf(form(i), \"min\"), 0) + (inMenu() ? menuMain(input) : 0);\n  const canStep = (i: number): boolean => at[i]! + 1 < items[i]!.forms.length;\n  const tooWide = (i: number, cross: number): boolean => !isMenu(form(i)) && !formSetsCross(form(i)) && crossMin(form(i)) > cross + EPS;\n\n  let cross = crossOf();\n  let overflow = 0;\n  const guard = items.reduce((s, it) => s + it.forms.length, 0) + 1;\n  for (let n = 0; n <= guard; n++) {\n    cross = crossOf();\n    // Too wide for the stack: step down, but never into the menu (that is the length's call).\n    let stepped = false;\n    for (const i of idx) {\n      if (tooWide(i, cross) && canStep(i) && !isMenu(items[i]!.forms[at[i]! + 1]!)) {\n        step(i);\n        stepped = true;\n      }\n    }\n    if (stepped) continue;\n    const over = minSum() - length;\n    if (over <= EPS) break;\n    const v = victim(items, at);\n    if (v < 0) {\n      overflow = over;\n      break;\n    }\n    // Into the menu only when that helps, or when something else can still give way.\n    const intoMenu = isMenu(items[v]!.forms[at[v]! + 1]!);\n    const gain = mainOf(form(v), \"min\") - (inMenu() ? 0 : menuMain(input));\n    if (intoMenu && gain < 0 && idx.filter(canStep).length === 1) {\n      overflow = over;\n      break;\n    }\n    step(v);\n  }\n  cross = crossOf();\n\n  // Sizes along the stack.\n  const menuSize = inMenu() ? menuMain(input) : 0;\n  const avail = Math.max(0, length - menuSize);\n  const drawn = idx.filter((i) => !isMenu(form(i)));\n  const min = (i: number): number => mainOf(form(i), \"min\");\n  const nat = (i: number): number => Math.max(min(i), mainOf(form(i), \"natural\"));\n  const sumMin = drawn.reduce((s, i) => s + min(i), 0);\n  const sumNat = drawn.reduce((s, i) => s + nat(i), 0);\n  const size = new Map<number, number>();\n  if (sumNat <= avail + EPS) {\n    const growers = drawn.filter((i) => form(i).main.grows);\n    const spare = Math.max(0, avail - sumNat);\n    const weight = growers.reduce((s, i) => s + nat(i), 0);\n    for (const i of drawn) {\n      const share = growers.includes(i) ? (weight > EPS ? nat(i) / weight : 1 / growers.length) : 0;\n      size.set(i, nat(i) + spare * share);\n    }\n  } else {\n    const t = avail > sumMin && sumNat > sumMin ? (avail - sumMin) / (sumNat - sumMin) : 0;\n    for (const i of drawn) size.set(i, min(i) + (nat(i) - min(i)) * t);\n  }\n\n  const rectAt = (from: number, main: number): Rect => (input.axis === \"column\" ? { x: 0, y: from, width: cross, height: main } : { x: from, y: 0, width: main, height: cross });\n  const rects = new Map<number, Rect>();\n  let cursor = 0;\n  for (const i of drawn) {\n    const s = size.get(i)!;\n    rects.set(i, rectAt(cursor, s));\n    cursor += s;\n  }\n  const menuRect = rectAt(Math.max(cursor, length - menuSize), menuSize);\n  const inside = idx.filter((i) => isMenu(form(i)));\n  const menu: StackMenu | null = inside.length > 0 ? { rect: menuRect, items: inside.map((i) => items[i]!.id) } : null;\n\n  const placed: PlacedStackItem[] = idx.map((i) => ({ id: items[i]!.id, form: at[i]!, kind: form(i).kind, rect: isMenu(form(i)) ? menuRect : rects.get(i)! }));\n\n  const notes: StackNote[] = [];\n  for (const it of input.items) if (it.forms.length === 0) notes.push({ code: \"no-forms\", id: it.id });\n  for (const i of firstStep) if (at[i]! > start[i]!) notes.push({ code: \"form-down\", id: items[i]!.id, from: start[i]!, to: at[i]! });\n  for (const i of menuOrder) if (isMenu(form(i))) notes.push({ code: \"to-menu\", id: items[i]!.id });\n  for (const i of idx) if (tooWide(i, cross)) notes.push({ code: \"too-wide\", id: items[i]!.id });\n  if (overflow > EPS) notes.push({ code: \"overflow\", over: overflow });\n  return { axis: input.axis, length, cross, items: placed, menu, notes };\n}\n","/**\n * The drop targets for dragging an item into a stack, in the shape @n-uf/motion/drag takes. `stackTargets(input,\n * dragged)` gives one target for every gap of the stack without the dragged item (an item of the input with its id\n * is lifted out first, so a reorder within a stack works): before each item and after the last, so an empty stack has\n * one. An item with no forms has no place of its own, but its gaps count.\n *\n * - `id` `gap:<k>`, priority 2, `place` `{ kind: \"gap\", at: k }` (k counts the input's items, the dragged one lifted\n *   out, including any with no forms; it is not an index into `fit.items`, which leaves those out: look the dragged\n *   item up there by its id, as `slot` already does).\n * - `hit`: the gap's zone along the axis, the stack split at its items' middles (an item in the menu has no place of\n *   its own: the gaps next to it split the stretch where the stack's drawn items end; with every item in the menu only\n *   the last gap, \"at the end\", has any length, and the others are a point at the start). Across, it is the larger of\n *   the stack's current size and the size the drop gives it, so the pointer over the preview is over the target.\n * - `fit`: the full `fitStack` of the stack with the dragged item inserted at k, and `input` the stack that was\n *   solved. The preview is `slot`, the dragged item's rect in `fit`: exactly the rect it gets after the drop, because\n *   the drop is that same solve. `marker` is the line where its leading edge lands: a rect with no thickness across\n *   the stack's cross size (the app draws it with one).\n *\n * The dragged item counts as just used: it is newer than every item in the stack, so the others give way before it.\n * A group lands in the form that fits; a panel that would set a wider column makes room by that solve too. A dragged\n * item with no forms has no targets.\n */\nimport { rect, type Rect } from \"../geometry\";\nimport type { Target } from \"../targets/target\";\nimport { fitStack } from \"./layout\";\nimport { withItem, type StackFit, type StackInput, type StackItem } from \"./model\";\n\nexport type StackPlace = { readonly kind: \"gap\"; readonly at: number };\n\nexport interface StackTarget extends Target {\n  readonly priority: 2;\n  /** The item dragged. */\n  readonly item: string;\n  readonly place: StackPlace;\n  /** The line where the dragged item's leading edge lands. */\n  readonly marker: Rect;\n  /** The stack with the dragged item inserted: what a drop here makes. */\n  readonly input: StackInput;\n  /** Its fit: the preview and the drop are both its rect for the dragged item. */\n  readonly fit: StackFit;\n}\n\n/** The gap boundaries along the axis: `b[0]` is the start, `b[k]` the middle of item k - 1, `b[n + 1]` the length. */\nfunction bounds(input: StackInput, fit: StackFit): number[] {\n  const column = input.axis === \"column\";\n  const start = (r: Rect): number => (column ? r.y : r.x);\n  const size = (r: Rect): number => (column ? r.height : r.width);\n  const placed = new Map(fit.items.map((p) => [p.id, p]));\n  const b = [0];\n  // Where the drawn items have ended so far: an item in the menu (or with no forms) sits there.\n  let end = 0;\n  for (const it of input.items) {\n    const p = placed.get(it.id);\n    if (!p || p.kind === \"menu\") {\n      b.push(end);\n      continue;\n    }\n    b.push(start(p.rect) + size(p.rect) / 2);\n    end = start(p.rect) + size(p.rect);\n  }\n  b.push(fit.length);\n  // Monotone, whatever the sizes did (a stack that overflows).\n  for (let i = 1; i < b.length; i++) b[i] = Math.min(Math.max(b[i]!, b[i - 1]!), fit.length);\n  return b;\n}\n\nexport function stackTargets(input: StackInput, dragged: StackItem): StackTarget[] {\n  if (dragged.forms.length === 0) return [];\n  const rest: StackInput = { ...input, items: input.items.filter((it) => it.id !== dragged.id) };\n  const base = fitStack(rest);\n  const b = bounds(rest, base);\n  const column = rest.axis === \"column\";\n  const newest = rest.items.reduce((m, it) => Math.max(m, it.used), dragged.used) + 1;\n  const item: StackItem = { ...dragged, used: newest };\n  const out: StackTarget[] = [];\n  for (let k = 0; k <= rest.items.length; k++) {\n    const solved = withItem(rest, item, k);\n    const fit = fitStack(solved);\n    const slot = fit.items.find((p) => p.id === dragged.id)!.rect;\n    const from = b[k]!;\n    const to = b[k + 1]!;\n    const across = Math.max(base.cross, fit.cross);\n    out.push({\n      id: `gap:${k}`,\n      priority: 2,\n      item: dragged.id,\n      place: { kind: \"gap\", at: k },\n      hit: column ? rect(0, from, across, to - from) : rect(from, 0, to - from, across),\n      slot,\n      marker: column ? rect(slot.x, slot.y, slot.width, 0) : rect(slot.x, slot.y, 0, slot.height),\n      input: solved,\n      fit,\n    });\n  }\n  return out;\n}\n","/**\n * The stack's stored form: `storeStack(state)` gives plain JSON-safe data (`{ v: 1, order, kept, closed, used, forms\n * }`); `readStack(data, known?)` reads parsed data back and never throws. Anything but an object of version 1 is\n * `{ ok: false, error }`. Inside one it is lenient, as the panels' reader is: an id that isn't a string, is repeated\n * or (with `known`) isn't one the consumer has is dropped and listed in `dropped`; a `kept`, `closed`, `used` or\n * `forms` entry for an id that isn't in `order` is dropped; a form that isn't a whole number from 1 up is dropped;\n * the key `__proto__` in `forms` is dropped (the other keys, `constructor` and `prototype` included, are ids like any\n * other: `forms` is an object with no prototype, written and read); a field this version doesn't know is skipped and\n * reported as `\"<field>\"`. An item the consumer has that the stored order lacks is no error: the consumer places it.\n *\n * - `kept`: items kept open (they give way last).\n * - `closed`: items the user closed; their place in `order` is kept for when they open.\n * - `used`: the use order, oldest to newest, so a reload restores who gives way first (an item's `used` is its index in\n *   it; one the list lacks is older than all). An id listed twice counts at its last place: the newest use wins.\n * - `forms`: the user's chosen form per item, the index of the largest form it may take (`StackItem.from`). 0, the\n *   first, is not stored.\n */\n\nexport interface StackState {\n  /** The items' order along the stack. */\n  readonly order: readonly string[];\n  /** Items kept open: they give way last. */\n  readonly kept: readonly string[];\n  /** Items the user closed. */\n  readonly closed: readonly string[];\n  /** The use order, oldest first. */\n  readonly used: readonly string[];\n  /** The form index the user chose per item (only those that chose one; absent means the first). */\n  readonly forms: Readonly<Record<string, number>>;\n}\n\nexport interface StoredStack {\n  readonly v: 1;\n  readonly order: string[];\n  readonly kept: string[];\n  readonly closed: string[];\n  readonly used: string[];\n  readonly forms: Record<string, number>;\n}\n\nexport type StackRead = { readonly ok: true; readonly state: StackState; readonly dropped: readonly string[] } | { readonly ok: false; readonly error: string };\n\n/** A state with these items in this order, none kept or closed, used in that order, every form the first. */\nexport const createStack = (order: readonly string[]): StackState => ({ order: [...order], kept: [], closed: [], used: [...order], forms: {} });\n\nconst isForm = (f: unknown): f is number => typeof f === \"number\" && Number.isInteger(f) && f >= 1;\n/** Ids that are in `order`, each once, at the first place it was listed. */\nconst uniq = (ids: readonly string[], order: readonly string[]): string[] => [...new Set(ids)].filter((id) => order.includes(id));\n/** Ids that are in `order`, each once, at the last place it was listed (the newest use wins). */\nconst uniqLast = (ids: readonly string[], order: readonly string[]): string[] => ids.filter((id, i) => order.includes(id) && ids.lastIndexOf(id) === i);\n/** Forms live in an object with no prototype, so no key (`constructor`, `prototype`) is more than a key; only `__proto__` is refused. */\nconst noForms = (): Record<string, number> => Object.create(null) as Record<string, number>;\n\nexport function storeStack(state: StackState): StoredStack {\n  const forms = noForms();\n  for (const id of state.order) {\n    const f = state.forms[id];\n    if (id !== \"__proto__\" && Object.hasOwn(state.forms, id) && isForm(f)) forms[id] = f;\n  }\n  return { v: 1, order: [...state.order], kept: uniq(state.kept, state.order), closed: uniq(state.closed, state.order), used: uniqLast(state.used, state.order), forms };\n}\n\nconst isObject = (x: unknown): x is Record<string, unknown> => typeof x === \"object\" && x !== null && !Array.isArray(x);\n\nexport function readStack(data: unknown, known?: readonly string[]): StackRead {\n  try {\n    return read(data, known);\n  } catch (e) {\n    // A getter that throws, a proxy: still no throw.\n    return { ok: false, error: `unreadable: ${e instanceof Error ? e.message : typeof e}` };\n  }\n}\n\nconst versionWords = (v: unknown): string => (typeof v === \"number\" ? String(v) : typeof v === \"string\" ? JSON.stringify(v.length > 24 ? `${v.slice(0, 24)}…` : v) : typeof v);\n\nfunction read(data: unknown, known?: readonly string[]): StackRead {\n  if (!isObject(data)) return { ok: false, error: \"not an object\" };\n  if (data.v !== 1) return { ok: false, error: `unknown version ${versionWords(data.v)} (this reads version 1)` };\n  if (!Array.isArray(data.order)) return { ok: false, error: \"order is missing\" };\n  const dropped: string[] = [];\n  const drop = (what: string): void => {\n    if (!dropped.includes(what)) dropped.push(what);\n  };\n  for (const k of Object.keys(data)) if (![\"v\", \"order\", \"kept\", \"closed\", \"used\", \"forms\"].includes(k)) drop(k);\n  const order: string[] = [];\n  for (const x of data.order as unknown[]) {\n    if (typeof x !== \"string\") drop(`a ${typeof x} where an id goes`);\n    else if ((known && !known.includes(x)) || order.includes(x)) drop(x);\n    else order.push(x);\n  }\n  // A list of ids that are in `order`, each once: at the first place it was listed, or for `used` the last (the newest use wins).\n  const list = (key: \"kept\" | \"closed\" | \"used\"): string[] => {\n    const out: string[] = [];\n    const x = data[key];\n    if (x === undefined) return out;\n    if (!Array.isArray(x)) {\n      drop(key);\n      return out;\n    }\n    for (const id of x as unknown[]) {\n      if (typeof id === \"string\" && order.includes(id)) {\n        if (key === \"used\" && out.includes(id)) out.splice(out.indexOf(id), 1);\n        if (!out.includes(id)) out.push(id);\n      } else drop(typeof id === \"string\" ? `${key}:${id}` : `a ${typeof id} in ${key}`);\n    }\n    return out;\n  };\n  const kept = list(\"kept\");\n  const closed = list(\"closed\");\n  const used = list(\"used\");\n  const forms = noForms();\n  if (data.forms !== undefined) {\n    if (!isObject(data.forms)) drop(\"forms\");\n    else {\n      for (const id of Object.keys(data.forms)) {\n        const f = data.forms[id];\n        if (id === \"__proto__\" || !Object.hasOwn(data.forms, id) || !order.includes(id) || !isForm(f)) drop(`forms:${id}`);\n        else forms[id] = f;\n      }\n    }\n  }\n  return { ok: true, state: { order, kept, closed, used, forms }, dropped };\n}\n"],"mappings":"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","names":["finite","cross"]}