agentlas 1.0.41 → 1.0.43

package/engine/vendor/tui/components/scroll-view.js

@@ -0,0 +1,173 @@
+import { LAYOUT_NODE } from "../layout-node.js";
+import { Container } from "../tui.js";
+export class ScrollView extends Container {
+    child;
+    followEnd;
+    primary;
+    overscroll;
+    scrollbarStyle;
+    currentScrollbar;
+    scrollbarHideDelayMs;
+    currentScrollTop = 0;
+    contentHeight = 0;
+    currentViewportHeight = 0;
+    followingEnd;
+    requestRenderCallback;
+    transientScrollbarVisible = false;
+    scrollbarActive = false;
+    scrollbarHideTimer;
+    constructor(component, options = {}) {
+        super();
+        if (options.axis !== undefined && options.axis !== "vertical") {
+            throw new Error(`Unsupported ScrollView axis: ${options.axis}`);
+        }
+        this.child = component;
+        this.children.push(component);
+        this.followEnd = (options.follow ?? "none") === "end";
+        this.followingEnd = this.followEnd;
+        this.primary = options.primary ?? false;
+        this.overscroll = options.overscroll ?? "chain";
+        this.currentScrollbar = options.scrollbar ?? "hidden";
+        this.scrollbarStyle = options.scrollbarStyle ?? ((text) => `\x1b[100m${text}\x1b[49m`);
+        this.scrollbarHideDelayMs = Math.max(0, Math.floor(options.scrollbarHideDelayMs ?? 1000));
+    }
+    get scrollTop() {
+        return this.currentScrollTop;
+    }
+    get isFollowingEnd() {
+        return this.followingEnd;
+    }
+    get viewportHeight() {
+        return this.currentViewportHeight;
+    }
+    get scrollbar() {
+        return this.currentScrollbar;
+    }
+    get isScrollbarVisible() {
+        if (this.scrollbar === "always")
+            return this.currentViewportHeight > 0;
+        return (this.scrollbar === "auto" && this.contentHeight > this.currentViewportHeight && this.transientScrollbarVisible);
+    }
+    setScrollbar(scrollbar) {
+        if (scrollbar === this.currentScrollbar)
+            return;
+        this.currentScrollbar = scrollbar;
+        if (scrollbar !== "auto")
+            this.hideTransientScrollbar();
+        else if (this.scrollbarActive)
+            this.markScrollbarActivity();
+        this.requestRenderCallback?.();
+    }
+    getContentWidth(width) {
+        return this.scrollbar === "always" && width > 1 ? width - 1 : width;
+    }
+    markScrollbarActivity() {
+        if (this.scrollbar !== "auto" || this.contentHeight <= this.currentViewportHeight)
+            return;
+        this.transientScrollbarVisible = true;
+        if (this.scrollbarHideTimer) {
+            clearTimeout(this.scrollbarHideTimer);
+            this.scrollbarHideTimer = undefined;
+        }
+        if (this.scrollbarActive)
+            return;
+        this.scrollbarHideTimer = setTimeout(() => {
+            this.scrollbarHideTimer = undefined;
+            this.transientScrollbarVisible = false;
+            this.requestRenderCallback?.();
+        }, this.scrollbarHideDelayMs);
+        this.scrollbarHideTimer.unref();
+    }
+    hideTransientScrollbar() {
+        this.transientScrollbarVisible = false;
+        if (!this.scrollbarHideTimer)
+            return;
+        clearTimeout(this.scrollbarHideTimer);
+        this.scrollbarHideTimer = undefined;
+    }
+    setScrollbarActive(active) {
+        if (active === this.scrollbarActive)
+            return;
+        this.scrollbarActive = active;
+        this.markScrollbarActivity();
+    }
+    scrollTo(scrollTop) {
+        const requested = Number.isFinite(scrollTop) ? Math.trunc(scrollTop) : this.currentScrollTop;
+        const maxScrollTop = Math.max(0, this.contentHeight - this.currentViewportHeight);
+        const next = Math.max(0, Math.min(maxScrollTop, requested));
+        if (next === this.currentScrollTop)
+            return;
+        this.currentScrollTop = next;
+        this.followingEnd = this.followEnd && next === maxScrollTop;
+        this.markScrollbarActivity();
+        this.requestRenderCallback?.();
+    }
+    scrollBy(lines) {
+        const requested = Number.isFinite(lines) ? Math.trunc(lines) : 0;
+        if (requested === 0)
+            return 0;
+        const maxScrollTop = Math.max(0, this.contentHeight - this.currentViewportHeight);
+        const start = this.followingEnd ? maxScrollTop : this.currentScrollTop;
+        const next = Math.max(0, Math.min(maxScrollTop, start + requested));
+        const moved = next - start;
+        this.currentScrollTop = next;
+        this.followingEnd = this.followEnd && next === maxScrollTop;
+        if (moved !== 0) {
+            this.markScrollbarActivity();
+            this.requestRenderCallback?.();
+        }
+        return requested - moved;
+    }
+    scrollToStart() {
+        const changed = this.currentScrollTop !== 0 ||
+            this.followingEnd !== (this.followEnd && this.contentHeight <= this.currentViewportHeight);
+        this.currentScrollTop = 0;
+        this.followingEnd = this.followEnd && this.contentHeight <= this.currentViewportHeight;
+        if (changed) {
+            this.markScrollbarActivity();
+            this.requestRenderCallback?.();
+        }
+    }
+    scrollToEnd() {
+        const next = Math.max(0, this.contentHeight - this.currentViewportHeight);
+        const changed = this.currentScrollTop !== next || this.followingEnd !== this.followEnd;
+        this.currentScrollTop = next;
+        this.followingEnd = this.followEnd;
+        if (changed) {
+            this.markScrollbarActivity();
+            this.requestRenderCallback?.();
+        }
+    }
+    updateLayout(contentHeight, viewportHeight, requestRender) {
+        this.contentHeight = Math.max(0, Math.floor(contentHeight));
+        this.currentViewportHeight = Math.max(0, Math.floor(viewportHeight));
+        this.requestRenderCallback = requestRender;
+        const maxScrollTop = Math.max(0, this.contentHeight - this.currentViewportHeight);
+        if (this.followingEnd)
+            this.currentScrollTop = maxScrollTop;
+        else
+            this.currentScrollTop = Math.max(0, Math.min(this.currentScrollTop, maxScrollTop));
+        if (this.followEnd && this.currentScrollTop === maxScrollTop)
+            this.followingEnd = true;
+        if (this.contentHeight <= this.currentViewportHeight)
+            this.hideTransientScrollbar();
+    }
+    addChild(_component) {
+        throw new Error("ScrollView has exactly one child");
+    }
+    removeChild(_component) {
+        throw new Error("ScrollView child cannot be removed");
+    }
+    clear() {
+        throw new Error("ScrollView child cannot be cleared");
+    }
+    render(width) {
+        const contentWidth = this.getContentWidth(width);
+        const lines = this.child.render(contentWidth);
+        return contentWidth === width ? lines : lines.map((line) => `${line} `);
+    }
+    [LAYOUT_NODE]() {
+        return { type: "scroll", component: this.child, state: this };
+    }
+}
+//# sourceMappingURL=scroll-view.js.map

package/engine/vendor/tui/components/select-list.js

@@ -0,0 +1,159 @@
+import { getKeybindings } from "../keybindings.js";
+import { truncateToWidth, visibleWidth } from "../utils.js";
+const DEFAULT_PRIMARY_COLUMN_WIDTH = 32;
+const PRIMARY_COLUMN_GAP = 2;
+const MIN_DESCRIPTION_WIDTH = 10;
+const normalizeToSingleLine = (text) => text.replace(/[\r\n]+/g, " ").trim();
+const clamp = (value, min, max) => Math.max(min, Math.min(value, max));
+export class SelectList {
+    items = [];
+    filteredItems = [];
+    selectedIndex = 0;
+    maxVisible = 5;
+    theme;
+    layout;
+    onSelect;
+    onCancel;
+    onSelectionChange;
+    constructor(items, maxVisible, theme, layout = {}) {
+        this.items = items;
+        this.filteredItems = items;
+        this.maxVisible = maxVisible;
+        this.theme = theme;
+        this.layout = layout;
+    }
+    setFilter(filter) {
+        this.filteredItems = this.items.filter((item) => item.value.toLowerCase().startsWith(filter.toLowerCase()));
+        // Reset selection when filter changes
+        this.selectedIndex = 0;
+    }
+    setSelectedIndex(index) {
+        this.selectedIndex = Math.max(0, Math.min(index, this.filteredItems.length - 1));
+    }
+    invalidate() {
+        // No cached state to invalidate currently
+    }
+    render(width) {
+        const lines = [];
+        // If no items match filter, show message
+        if (this.filteredItems.length === 0) {
+            lines.push(this.theme.noMatch("  No matching commands"));
+            return lines;
+        }
+        const primaryColumnWidth = this.getPrimaryColumnWidth();
+        // Calculate visible range with scrolling
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredItems.length - this.maxVisible));
+        const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+        // Render visible items
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = this.filteredItems[i];
+            if (!item)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            const descriptionSingleLine = item.description ? normalizeToSingleLine(item.description) : undefined;
+            lines.push(this.renderItem(item, isSelected, width, descriptionSingleLine, primaryColumnWidth));
+        }
+        // Add scroll indicators if needed
+        if (startIndex > 0 || endIndex < this.filteredItems.length) {
+            const scrollText = `  (${this.selectedIndex + 1}/${this.filteredItems.length})`;
+            // Truncate if too long for terminal
+            lines.push(this.theme.scrollInfo(truncateToWidth(scrollText, width - 2, "")));
+        }
+        return lines;
+    }
+    handleInput(keyData) {
+        const kb = getKeybindings();
+        // Up arrow - wrap to bottom when at top
+        if (kb.matches(keyData, "tui.select.up")) {
+            this.selectedIndex = this.selectedIndex === 0 ? this.filteredItems.length - 1 : this.selectedIndex - 1;
+            this.notifySelectionChange();
+        }
+        // Down arrow - wrap to top when at bottom
+        else if (kb.matches(keyData, "tui.select.down")) {
+            this.selectedIndex = this.selectedIndex === this.filteredItems.length - 1 ? 0 : this.selectedIndex + 1;
+            this.notifySelectionChange();
+        }
+        // Enter
+        else if (kb.matches(keyData, "tui.select.confirm")) {
+            const selectedItem = this.filteredItems[this.selectedIndex];
+            if (selectedItem && this.onSelect) {
+                this.onSelect(selectedItem);
+            }
+        }
+        // Escape or Ctrl+C
+        else if (kb.matches(keyData, "tui.select.cancel")) {
+            if (this.onCancel) {
+                this.onCancel();
+            }
+        }
+    }
+    renderItem(item, isSelected, width, descriptionSingleLine, primaryColumnWidth) {
+        const prefix = isSelected ? "→ " : "  ";
+        const prefixWidth = visibleWidth(prefix);
+        if (descriptionSingleLine && width > 40) {
+            const effectivePrimaryColumnWidth = Math.max(1, Math.min(primaryColumnWidth, width - prefixWidth - 4));
+            const maxPrimaryWidth = Math.max(1, effectivePrimaryColumnWidth - PRIMARY_COLUMN_GAP);
+            const truncatedValue = this.truncatePrimary(item, isSelected, maxPrimaryWidth, effectivePrimaryColumnWidth);
+            const truncatedValueWidth = visibleWidth(truncatedValue);
+            const spacing = " ".repeat(Math.max(1, effectivePrimaryColumnWidth - truncatedValueWidth));
+            const descriptionStart = prefixWidth + truncatedValueWidth + spacing.length;
+            const remainingWidth = width - descriptionStart - 2; // -2 for safety
+            if (remainingWidth > MIN_DESCRIPTION_WIDTH) {
+                const truncatedDesc = truncateToWidth(descriptionSingleLine, remainingWidth, "");
+                if (isSelected) {
+                    return this.theme.selectedText(`${prefix}${truncatedValue}${spacing}${truncatedDesc}`);
+                }
+                const descText = this.theme.description(spacing + truncatedDesc);
+                return prefix + truncatedValue + descText;
+            }
+        }
+        const maxWidth = width - prefixWidth - 2;
+        const truncatedValue = this.truncatePrimary(item, isSelected, maxWidth, maxWidth);
+        if (isSelected) {
+            return this.theme.selectedText(`${prefix}${truncatedValue}`);
+        }
+        return prefix + truncatedValue;
+    }
+    getPrimaryColumnWidth() {
+        const { min, max } = this.getPrimaryColumnBounds();
+        const widestPrimary = this.filteredItems.reduce((widest, item) => {
+            return Math.max(widest, visibleWidth(this.getDisplayValue(item)) + PRIMARY_COLUMN_GAP);
+        }, 0);
+        return clamp(widestPrimary, min, max);
+    }
+    getPrimaryColumnBounds() {
+        const rawMin = this.layout.minPrimaryColumnWidth ?? this.layout.maxPrimaryColumnWidth ?? DEFAULT_PRIMARY_COLUMN_WIDTH;
+        const rawMax = this.layout.maxPrimaryColumnWidth ?? this.layout.minPrimaryColumnWidth ?? DEFAULT_PRIMARY_COLUMN_WIDTH;
+        return {
+            min: Math.max(1, Math.min(rawMin, rawMax)),
+            max: Math.max(1, Math.max(rawMin, rawMax)),
+        };
+    }
+    truncatePrimary(item, isSelected, maxWidth, columnWidth) {
+        const displayValue = this.getDisplayValue(item);
+        const truncatedValue = this.layout.truncatePrimary
+            ? this.layout.truncatePrimary({
+                text: displayValue,
+                maxWidth,
+                columnWidth,
+                item,
+                isSelected,
+            })
+            : truncateToWidth(displayValue, maxWidth, "");
+        return truncateToWidth(truncatedValue, maxWidth, "");
+    }
+    getDisplayValue(item) {
+        return item.label || item.value;
+    }
+    notifySelectionChange() {
+        const selectedItem = this.filteredItems[this.selectedIndex];
+        if (selectedItem && this.onSelectionChange) {
+            this.onSelectionChange(selectedItem);
+        }
+    }
+    getSelectedItem() {
+        const item = this.filteredItems[this.selectedIndex];
+        return item || null;
+    }
+}
+//# sourceMappingURL=select-list.js.map

package/engine/vendor/tui/components/settings-list.js

@@ -0,0 +1,182 @@
+import { fuzzyFilter } from "../fuzzy.js";
+import { getKeybindings } from "../keybindings.js";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../utils.js";
+import { Input } from "./input.js";
+export class SettingsList {
+    items;
+    filteredItems;
+    theme;
+    selectedIndex = 0;
+    maxVisible;
+    onChange;
+    onCancel;
+    searchInput;
+    searchEnabled;
+    // Submenu state
+    submenuComponent = null;
+    submenuItemIndex = null;
+    constructor(items, maxVisible, theme, onChange, onCancel, options = {}) {
+        this.items = items;
+        this.filteredItems = items;
+        this.maxVisible = maxVisible;
+        this.theme = theme;
+        this.onChange = onChange;
+        this.onCancel = onCancel;
+        this.searchEnabled = options.enableSearch ?? false;
+        if (this.searchEnabled) {
+            this.searchInput = new Input();
+        }
+    }
+    /** Update an item's currentValue */
+    updateValue(id, newValue) {
+        const item = this.items.find((i) => i.id === id);
+        if (item) {
+            item.currentValue = newValue;
+        }
+    }
+    invalidate() {
+        this.submenuComponent?.invalidate?.();
+    }
+    render(width) {
+        // If submenu is active, render it instead
+        if (this.submenuComponent) {
+            return this.submenuComponent.render(width);
+        }
+        return this.renderMainList(width);
+    }
+    renderMainList(width) {
+        const lines = [];
+        if (this.searchEnabled && this.searchInput) {
+            lines.push(...this.searchInput.render(width));
+            lines.push("");
+        }
+        if (this.items.length === 0) {
+            lines.push(this.theme.hint("  No settings available"));
+            if (this.searchEnabled) {
+                this.addHintLine(lines, width);
+            }
+            return lines;
+        }
+        const displayItems = this.searchEnabled ? this.filteredItems : this.items;
+        if (displayItems.length === 0) {
+            lines.push(truncateToWidth(this.theme.hint("  No matching settings"), width));
+            this.addHintLine(lines, width);
+            return lines;
+        }
+        // Calculate visible range with scrolling
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), displayItems.length - this.maxVisible));
+        const endIndex = Math.min(startIndex + this.maxVisible, displayItems.length);
+        // Calculate max label width for alignment
+        const maxLabelWidth = Math.min(30, Math.max(...this.items.map((item) => visibleWidth(item.label))));
+        // Render visible items
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = displayItems[i];
+            if (!item)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            const prefix = isSelected ? this.theme.cursor : "  ";
+            const prefixWidth = visibleWidth(prefix);
+            // Pad label to align values
+            const labelPadded = item.label + " ".repeat(Math.max(0, maxLabelWidth - visibleWidth(item.label)));
+            const labelText = this.theme.label(labelPadded, isSelected);
+            // Calculate space for value
+            const separator = "  ";
+            const usedWidth = prefixWidth + maxLabelWidth + visibleWidth(separator);
+            const valueMaxWidth = width - usedWidth - 2;
+            const valueText = this.theme.value(truncateToWidth(item.currentValue, valueMaxWidth, ""), isSelected);
+            lines.push(truncateToWidth(prefix + labelText + separator + valueText, width));
+        }
+        // Add scroll indicator if needed
+        if (startIndex > 0 || endIndex < displayItems.length) {
+            const scrollText = `  (${this.selectedIndex + 1}/${displayItems.length})`;
+            lines.push(this.theme.hint(truncateToWidth(scrollText, width - 2, "")));
+        }
+        // Add description for selected item
+        const selectedItem = displayItems[this.selectedIndex];
+        if (selectedItem?.description) {
+            lines.push("");
+            const wrappedDesc = wrapTextWithAnsi(selectedItem.description, width - 4);
+            for (const line of wrappedDesc) {
+                lines.push(this.theme.description(`  ${line}`));
+            }
+        }
+        // Add hint
+        this.addHintLine(lines, width);
+        return lines;
+    }
+    handleInput(data) {
+        // If submenu is active, delegate all input to it
+        // The submenu's onCancel (triggered by escape) will call done() which closes it
+        if (this.submenuComponent) {
+            this.submenuComponent.handleInput?.(data);
+            return;
+        }
+        // Main list input handling
+        const kb = getKeybindings();
+        const displayItems = this.searchEnabled ? this.filteredItems : this.items;
+        if (kb.matches(data, "tui.select.up")) {
+            if (displayItems.length === 0)
+                return;
+            this.selectedIndex = this.selectedIndex === 0 ? displayItems.length - 1 : this.selectedIndex - 1;
+        }
+        else if (kb.matches(data, "tui.select.down")) {
+            if (displayItems.length === 0)
+                return;
+            this.selectedIndex = this.selectedIndex === displayItems.length - 1 ? 0 : this.selectedIndex + 1;
+        }
+        else if (kb.matches(data, "tui.select.confirm") ||
+            (data === " " && (!this.searchEnabled || this.searchInput?.getValue().length === 0))) {
+            this.activateItem();
+        }
+        else if (kb.matches(data, "tui.select.cancel")) {
+            this.onCancel();
+        }
+        else if (this.searchEnabled && this.searchInput) {
+            this.searchInput.handleInput(data);
+            this.applyFilter(this.searchInput.getValue());
+        }
+    }
+    activateItem() {
+        const item = this.searchEnabled ? this.filteredItems[this.selectedIndex] : this.items[this.selectedIndex];
+        if (!item)
+            return;
+        if (item.submenu) {
+            // Open submenu, passing current value so it can pre-select correctly
+            this.submenuItemIndex = this.selectedIndex;
+            this.submenuComponent = item.submenu(item.currentValue, (selectedValue) => {
+                if (selectedValue !== undefined) {
+                    item.currentValue = selectedValue;
+                    this.onChange(item.id, selectedValue);
+                }
+                this.closeSubmenu();
+            });
+        }
+        else if (item.values && item.values.length > 0) {
+            // Cycle through values
+            const currentIndex = item.values.indexOf(item.currentValue);
+            const nextIndex = (currentIndex + 1) % item.values.length;
+            const newValue = item.values[nextIndex];
+            item.currentValue = newValue;
+            this.onChange(item.id, newValue);
+        }
+    }
+    closeSubmenu() {
+        this.submenuComponent = null;
+        // Restore selection to the item that opened the submenu
+        if (this.submenuItemIndex !== null) {
+            this.selectedIndex = this.submenuItemIndex;
+            this.submenuItemIndex = null;
+        }
+    }
+    applyFilter(query) {
+        this.filteredItems = fuzzyFilter(this.items, query, (item) => item.label);
+        this.selectedIndex = 0;
+    }
+    addHintLine(lines, width) {
+        lines.push("");
+        lines.push(truncateToWidth(this.theme.hint(this.searchEnabled
+            ? "  Type to search · Enter/Space to change · Esc to cancel"
+            : "  Enter/Space to change · Esc to cancel"), width));
+    }
+}
+//# sourceMappingURL=settings-list.js.map

package/engine/vendor/tui/components/spacer.js

@@ -0,0 +1,23 @@
+/**
+ * Spacer component that renders empty lines
+ */
+export class Spacer {
+    lines;
+    constructor(lines = 1) {
+        this.lines = lines;
+    }
+    setLines(lines) {
+        this.lines = lines;
+    }
+    invalidate() {
+        // No cached state to invalidate currently
+    }
+    render(_width) {
+        const result = [];
+        for (let i = 0; i < this.lines; i++) {
+            result.push("");
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=spacer.js.map

package/engine/vendor/tui/components/stack.js

@@ -0,0 +1,111 @@
+import { LAYOUT_NODE } from "../layout-node.js";
+import { Container } from "../tui.js";
+function isStackEntry(child) {
+    return !("render" in child);
+}
+function normalizeSize(value, fallback) {
+    return value === undefined || !Number.isFinite(value) ? fallback : Math.max(0, Math.floor(value));
+}
+export class Stack extends Container {
+    entries = [];
+    gap;
+    align;
+    constructor(children = [], options = {}) {
+        super();
+        this.gap = normalizeSize(options.gap, 0);
+        this.align = options.align ?? "stretch";
+        for (const child of children) {
+            if (isStackEntry(child))
+                this.addChild(child.component, child);
+            else
+                this.addChild(child);
+        }
+    }
+    addChild(component, options = {}) {
+        super.addChild(component);
+        this.entries.push({
+            component,
+            ...(options.basis === undefined ? {} : { basis: options.basis }),
+            ...(options.grow === undefined ? {} : { grow: normalizeSize(options.grow, 0) }),
+            ...(options.shrink === undefined ? {} : { shrink: normalizeSize(options.shrink, 1) }),
+            ...(options.minSize === undefined ? {} : { minSize: normalizeSize(options.minSize, 0) }),
+            ...(options.maxSize === undefined ? {} : { maxSize: normalizeSize(options.maxSize, Number.MAX_SAFE_INTEGER) }),
+            ...(options.visible === undefined ? {} : { visible: options.visible }),
+        });
+    }
+    removeChild(component) {
+        super.removeChild(component);
+        const index = this.entries.findIndex((entry) => entry.component === component);
+        if (index !== -1)
+            this.entries.splice(index, 1);
+    }
+    clear() {
+        super.clear();
+        this.entries.length = 0;
+    }
+    [LAYOUT_NODE]() {
+        return {
+            type: this.layoutType,
+            entries: this.entries,
+            gap: this.gap,
+            align: this.align,
+        };
+    }
+}
+export function visibleStackEntries(entries, viewport) {
+    return entries.filter((entry) => entry.visible?.(viewport) ?? true);
+}
+function clampSize(size, entry) {
+    const min = Math.max(0, Math.floor(entry.minSize ?? 0));
+    const max = Math.max(min, Math.floor(entry.maxSize ?? Number.MAX_SAFE_INTEGER));
+    return Math.max(min, Math.min(max, Math.max(0, Math.floor(size))));
+}
+function distribute(sizes, entries, amount, mode) {
+    let remaining = amount;
+    while (remaining > 0) {
+        const candidates = entries
+            .map((entry, index) => ({ entry, index }))
+            .filter(({ entry, index }) => {
+            if (mode === "grow") {
+                return (entry.grow ?? 0) > 0 && sizes[index] < (entry.maxSize ?? Number.MAX_SAFE_INTEGER);
+            }
+            return (entry.shrink ?? 1) > 0 && sizes[index] > (entry.minSize ?? 0);
+        });
+        if (candidates.length === 0)
+            return;
+        const totalWeight = candidates.reduce((sum, { entry, index }) => {
+            return sum + (mode === "grow" ? (entry.grow ?? 0) : (entry.shrink ?? 1) * Math.max(1, sizes[index]));
+        }, 0);
+        let distributed = 0;
+        for (const { entry, index } of candidates) {
+            if (remaining <= 0)
+                break;
+            const weight = mode === "grow" ? (entry.grow ?? 0) : (entry.shrink ?? 1) * Math.max(1, sizes[index]);
+            const proposed = Math.max(1, Math.floor((remaining * weight) / totalWeight));
+            const capacity = mode === "grow"
+                ? (entry.maxSize ?? Number.MAX_SAFE_INTEGER) - sizes[index]
+                : sizes[index] - (entry.minSize ?? 0);
+            const delta = Math.min(remaining, proposed, capacity);
+            if (delta <= 0)
+                continue;
+            sizes[index] = sizes[index] + (mode === "grow" ? delta : -delta);
+            remaining -= delta;
+            distributed += delta;
+        }
+        if (distributed === 0)
+            return;
+    }
+}
+export function allocateStackSizes(entries, intrinsicSizes, availableSize, gap) {
+    const sizes = entries.map((entry, index) => clampSize(entry.basis === undefined || entry.basis === "auto" ? (intrinsicSizes[index] ?? 0) : entry.basis, entry));
+    if (availableSize === undefined)
+        return sizes;
+    const contentSize = Math.max(0, Math.floor(availableSize) - Math.max(0, entries.length - 1) * gap);
+    const total = sizes.reduce((sum, size) => sum + size, 0);
+    if (total < contentSize)
+        distribute(sizes, entries, contentSize - total, "grow");
+    else if (total > contentSize)
+        distribute(sizes, entries, total - contentSize, "shrink");
+    return sizes;
+}
+//# sourceMappingURL=stack.js.map