@esportsplus/ui 0.56.4 → 0.57.0

package/build/components/editor/tree/index.js

@@ -0,0 +1,2227 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+import { ReactiveArray, effect, flush, peek, read, signal, untrack, write } from '@esportsplus/reactivity';
+import * as template_u1 from '@esportsplus/template';
+import { write as writeText } from '../../clipboard/index.js';
+import highlight from '../../highlight/index.js';
+import icon from '../../icon/index.js';
+import tooltip from '../../tooltip/index.js';
+import fuzzy from '../../../shared/fuzzy.js';
+import chevron from '@esportsplus/ui/svg/chevron-right.svg';
+import symlink from '@esportsplus/ui/svg/corner-down-right.svg';
+import lock from '@esportsplus/ui/svg/lock.svg';
+import Clipboard from './clipboard.js';
+import segments, { ancestors, caption, holds, lineage, same, SEGMENT, sole } from './compact.js';
+import Decorations, { merge } from './decorations.js';
+import draggable from './drag.js';
+import Editor, { field, resolve } from './edit.js';
+import filter, { recheck } from './filter.js';
+import Finder from './find.js';
+import glob from './glob.js';
+import glyph, { renderer } from './glyph.js';
+import History from './history.js';
+import { resolver as createFileTreeIconResolver, resolve as resolveFileTreeIcon } from './icons.js';
+import { enclosing, flagged, order, seek } from './jump.js';
+import Loader, { placeholder } from './lazy.js';
+import Elements from './model.js';
+import Selection from './selection.js';
+import command, { extending } from './shortcuts.js';
+import comparator from './sort.js';
+import spoken from './spoken.js';
+import stick from './sticky.js';
+import '../../button/scss/index.scss';
+import './scss/index.scss';
+const template_187wopb4 = template_u1.template(`<div class='file-tree-row     ' role='treeitem' style=';;;'>`);
+const template_187wopb7 = template_u1.template(`<span class='file-tree-tooltip-path'><!--$--><strong></strong></span><!--$-->`);
+const template_187wopbc = template_u1.template(`<span class='file-tree-tooltip-meta'>`);
+const template_187wopbf = template_u1.template(`<div aria-expanded='true' class='file-tree-row file-tree-row--pinned   ' style=';;'>`);
+const template_187wopbi = template_u1.template(`<span aria-hidden='true' class='file-tree-twistie'></span><!--$--><!--$--><!--$--><!--$--><!--$-->`);
+const template_187wopbq = template_u1.template(`<span class='file-tree-name'>`);
+const template_187wopbt = template_u1.template(`<!--$--><!--$-->`);
+const template_187wopbz = template_u1.template(`<span aria-hidden='true' class='file-tree-badge'>`);
+const template_187wopb12 = template_u1.template(`<div class='file-tree-row     '>`);
+const template_187wopb15 = template_u1.template(`<span class='file-tree-badge-part  '>`);
+const template_187wopb18 = template_u1.template(`<mark class='file-tree-match'>`);
+const template_187wopb1b = template_u1.template(`<div class='file-tree  '><div aria-multiselectable='true' class='file-tree-viewport' role='tree' tabindex='0'><!--$--><!--$--></div><div aria-hidden='true' class='file-tree-motion' inert><div class='file-tree-motion-layer'></div></div><!--$--><!--$--><!--$--><!--$-->`);
+const template_187wopb1n = template_u1.template(`<div class='file-tree-empty'>`);
+const template_187wopb1q = template_u1.template(`<button class='button file-tree-toggle' type='button'>`);
+class ReactiveObject_187wopb0 extends reactivity_u0.ReactiveObject {
+    #selected;
+    #selection;
+    constructor(_p0, _p1) {
+        super(null);
+        this.#selected = this[reactivity_u0.SIGNAL](_p0);
+        this.#selection = this[reactivity_u0.SIGNAL](_p1);
+    }
+    get selected() {
+        return reactivity_u0.read(this.#selected);
+    }
+    set selected(_v0) {
+        reactivity_u0.write(this.#selected, _v0);
+    }
+    get selection() {
+        return reactivity_u0.read(this.#selection);
+    }
+    set selection(_v1) {
+        reactivity_u0.write(this.#selection, _v1);
+    }
+}
+class ReactiveObject_187wopb1 extends reactivity_u0.ReactiveObject {
+    #edge = this[reactivity_u0.SIGNAL](0);
+    #height = this[reactivity_u0.SIGNAL](0);
+    #left = this[reactivity_u0.SIGNAL](0);
+    #top = this[reactivity_u0.SIGNAL](0);
+    #width = this[reactivity_u0.SIGNAL](0);
+    constructor() {
+        super(null);
+    }
+    get edge() {
+        return reactivity_u0.read(this.#edge);
+    }
+    set edge(_v0) {
+        reactivity_u0.write(this.#edge, _v0);
+    }
+    get height() {
+        return reactivity_u0.read(this.#height);
+    }
+    set height(_v1) {
+        reactivity_u0.write(this.#height, _v1);
+    }
+    get left() {
+        return reactivity_u0.read(this.#left);
+    }
+    set left(_v2) {
+        reactivity_u0.write(this.#left, _v2);
+    }
+    get top() {
+        return reactivity_u0.read(this.#top);
+    }
+    set top(_v3) {
+        reactivity_u0.write(this.#top, _v3);
+    }
+    get width() {
+        return reactivity_u0.read(this.#width);
+    }
+    set width(_v4) {
+        reactivity_u0.write(this.#width, _v4);
+    }
+}
+class ReactiveObject_187wopb2 extends reactivity_u0.ReactiveObject {
+    #any;
+    #motion;
+    #motionRows = this[reactivity_u0.SIGNAL](0);
+    constructor(_p0, _p1) {
+        super(null);
+        this.#any = this[reactivity_u0.SIGNAL](_p0);
+        this.#motion = this[reactivity_u0.SIGNAL](_p1);
+    }
+    get any() {
+        return reactivity_u0.read(this.#any);
+    }
+    set any(_v0) {
+        reactivity_u0.write(this.#any, _v0);
+    }
+    get motion() {
+        return reactivity_u0.read(this.#motion);
+    }
+    set motion(_v1) {
+        reactivity_u0.write(this.#motion, _v1);
+    }
+    get motionRows() {
+        return reactivity_u0.read(this.#motionRows);
+    }
+    set motionRows(_v2) {
+        reactivity_u0.write(this.#motionRows, _v2);
+    }
+}
+const BYTES = ['byte', 'kilobyte', 'megabyte', 'gigabyte', 'terabyte'].map((unit, i) => new Intl.NumberFormat(undefined, {
+    maximumFractionDigits: 1,
+    style: 'unit',
+    unit,
+    unitDisplay: i ? 'short' : 'long'
+}));
+const CHUNK = 8192;
+const GUIDES = [];
+const LETTERS = {
+    added: 'A',
+    conflict: '!',
+    deleted: 'D',
+    ignored: '',
+    modified: 'M',
+    renamed: 'R',
+    untracked: 'U'
+};
+const PREVIEW = { mode: 'preview', side: false };
+const RANK = ['ignored', 'added', 'modified', 'warning', 'deleted', 'conflict', 'error'];
+const REST = 200;
+const ROW = Symbol();
+const TONES = {
+    added: 'added',
+    conflict: 'conflict',
+    deleted: 'deleted',
+    ignored: 'ignored',
+    modified: 'modified',
+    renamed: 'added',
+    untracked: 'added'
+};
+const TOOLTIP = 600;
+const TYPEAHEAD = 500;
+const dates = new Intl.DateTimeFormat(undefined, { dateStyle: 'medium', timeStyle: 'short' });
+let uid = 0;
+function badge(decoration, lines, rollup) {
+    let editor = decoration?.editor, parts = [], staged = decoration?.staged, status = decoration?.status;
+    if (lines[0]) {
+        parts.push({ text: `+${lines[0]}`, tone: 'additions' });
+    }
+    if (lines[1]) {
+        parts.push({ text: `−${lines[1]}`, tone: 'deletions' });
+    }
+    for (let custom of decoration?.badges ?? []) {
+        parts.push({ color: custom.color, text: custom.text, title: custom.tooltip });
+    }
+    if (rollup === null && staged && LETTERS[staged]) {
+        parts.push({ staged: true, text: LETTERS[staged], title: 'Staged', tone: TONES[staged] });
+    }
+    if (rollup === null && status && LETTERS[status]) {
+        parts.push({ text: LETTERS[status], tone: TONES[status] });
+    }
+    if (decoration?.submodule) {
+        parts.push({ text: 'S', tone: 'submodule' });
+    }
+    if (rollup) {
+        parts.push({ text: '●', tone: rollup });
+    }
+    if (editor?.unsaved || editor?.open) {
+        parts.push({ text: editor.unsaved ? '●' : '○', tone: editor.unsaved ? 'unsaved' : 'open' });
+    }
+    return parts;
+}
+function bytes(value) {
+    let unit = 0;
+    while (value >= 1024 && unit < BYTES.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    return BYTES[unit].format(value);
+}
+function chip(part) {
+    return (() => {
+        let root_187wopb14 = template_187wopb15(), element_187wopb16 = root_187wopb14.firstChild;
+        template_u1.slot(element_187wopb16, part.text, 1);
+        template_u1.setList(element_187wopb16, 'class', part.staged && 'file-tree-badge-part--staged');
+        template_u1.setList(element_187wopb16, 'class', part.tone && `file-tree-badge-part--${part.tone}`);
+        template_u1.setList(element_187wopb16, 'style', part.color && `color: ${part.color}`);
+        template_u1.setProperties(element_187wopb16, !!part.title && { title: part.title });
+        return root_187wopb14;
+    })();
+}
+function emphasis(name, query) {
+    let match = query ? fuzzy(query, name) : null;
+    if (!match) {
+        return name;
+    }
+    let at = 0, indices = match.indices, out = [];
+    for (let i = 0, n = indices.length; i < n;) {
+        let end = indices[i] + 1, start = indices[i];
+        while (++i < n && indices[i] === end) {
+            end++;
+        }
+        if (start > at) {
+            out.push(name.slice(at, start));
+        }
+        out.push((() => {
+            let root_187wopb17 = template_187wopb18(), element_187wopb19 = root_187wopb17.firstChild;
+            template_u1.slot(element_187wopb19, name.slice(start, end), 1);
+            return root_187wopb17;
+        })());
+        at = end;
+    }
+    if (at < name.length) {
+        out.push(name.slice(at));
+    }
+    return out;
+}
+function found(block, mark) {
+    if (!mark) {
+        return mark;
+    }
+    return mark === 'current' ? `${block}--match ${block}--match-current` : `${block}--match`;
+}
+function folder(element) {
+    return element.type ? element.type === 'folder' : Array.isArray(element.children);
+}
+function guides(depth) {
+    let out = GUIDES[depth];
+    if (out !== undefined) {
+        return out;
+    }
+    let parts = [];
+    for (let i = 1; i < depth; i++) {
+        parts.push(`calc(var(--indent) * ${-i} * var(--guide-direction)) 0`);
+    }
+    return GUIDES[depth] = parts.join(', ') || 'none';
+}
+function lift(rank) {
+    return rank === RANK.indexOf('deleted') ? RANK.indexOf('modified') : rank;
+}
+function middle(event) {
+    if (event.button === 1) {
+        event.preventDefault();
+    }
+}
+function path(row) {
+    return [...ancestors(row), row].map((node) => node.element.name).join('/');
+}
+function pick(row, event) {
+    return event.target.closest('.file-tree-segment')?.[SEGMENT] ?? row;
+}
+function place(row) {
+    let out = [];
+    for (let node = row; node; node = node.parent) {
+        out.unshift(node.position);
+    }
+    return out;
+}
+function rank(decoration) {
+    if (!decoration) {
+        return -1;
+    }
+    if (decoration.errors) {
+        return RANK.indexOf('error');
+    }
+    let value = decoration.status ?? decoration.staged, status = value ? RANK.indexOf(TONES[value]) : -1;
+    return decoration.warnings ? Math.max(status, RANK.indexOf('warning')) : status;
+}
+function shown(row) {
+    let target = row;
+    for (let node = row.parent; node; node = node.parent) {
+        if (!peek(node.open)) {
+            target = node;
+        }
+    }
+    return target;
+}
+function trail(index, id) {
+    let entry = index.get(id), out = [];
+    if (!entry) {
+        return out;
+    }
+    if (folder(entry.element) && entry.element.selectable !== false) {
+        out.push(id);
+    }
+    for (let parent = entry.parent; parent !== null; parent = index.get(parent).parent) {
+        out.push(parent);
+    }
+    return out;
+}
+function twistie(event) {
+    return event.target.closest('.file-tree-twistie') !== null;
+}
+export default ({ compact = true, controller, create, decorations: providers, display = {}, drag, editor, elements, empty, exclude = [], expand: unfold = 'click', expanded = [], export: exporter, find = 'highlight', highlight: phrase = '', history, icon: draw, icons = {}, indicator = 'always', label = 'Files', load, menu, open: view, operations, path: address = (element) => element.id, preview, rename, reveal: autoreveal = 'on', roots = false, scopes = [], searched, select, selected, shortcuts, snapshot, sort = 'folders', state = new ReactiveObject_187wopb0(selected ?? '', new Set()), sticky = true, toggle, tooltip: hint = true, typing = 'typeahead', validate, ...attributes }) => {
+    let built = new Map(), chosen = untrack(() => state.selected), clipboard = new Clipboard(), compare = comparator(sort, folder), counts = new Map(), current = signal(chosen), decorations = providers && merge([providers].flat()), diffs = new Map(), draft = signal(null), excluded = glob(exclude), model = elements instanceof Elements ? elements : new Elements(elements), filtered = untrack(() => filter(model.elements, display.dotfiles !== false, excluded, roots)), ghosts = new ReactiveArray(), hidden = untrack(() => new Set([...filtered, ...(decorations?.keys() ?? [])].filter(gone))), id = `file-tree-${++uid}`, index = model.index, initial = new Set([
+        ...(snapshot?.expanded ?? expanded),
+        ...(roots && !snapshot?.expanded ? model.elements.map((element) => element.id) : []),
+        ...(autoreveal === 'off' ? [] : trail(index, chosen))
+    ]), key = 0, known = chosen, loader = load ? new Loader(load, loaded) : null, marks = new Map(), notes = new Map(), opened = 0, own = new Map(), places = new WeakMap(), given = signal(typeof phrase === 'function' ? untrack(phrase) : phrase), query = signal(''), remap = icons ? icons.remap ?? {} : {}, render = draw ?? (icons ? renderer(icons) : () => false), revealing = new Map(), search = find === 'off' ? null : new Finder(find, query, {
+        compare,
+        cursor: () => cursor && segment(cursor).id,
+        elements: model.elements,
+        folder,
+        go: (id) => reveal(id, true),
+        gone,
+        lazy: !!load,
+        leave: () => viewport?.focus({ preventScroll: true }),
+        searched,
+        shows: (id) => {
+            let row = built.get(id);
+            return !!row && !hidden.has(id) && shown(row) === row;
+        },
+        sift: (folders) => {
+            sift(folders);
+            slot.flush();
+        }
+    }), seen = model.version, settings = untrack(modes), shifts = 0, split = null, stage = new ReactiveObject_187wopb1(), sweep = signal(0), top = build(model.elements, 0, null), totals = new Map(), unfolded = new Map(), rows = reactivity_u0.reactive(visible(top)), cursor = rows.find((row) => holds(row, (id) => id === chosen)) ?? rows[0] ?? null, dragging = (drag || exporter || operations?.import) && draggable({ drag, export: exporter, import: operations?.import }, {
+        grab: (row) => (selection.has(row.id) ? [...selection.ids].map((id) => built.get(id)) : [row])
+            .filter((row) => row !== undefined && !header(row) && !ancestors(row).some((node) => selection.has(node.id) && !header(node))),
+        host: (row) => row.host ?? row,
+        last: (row) => {
+            let out = row;
+            while (out.open && peek(out.open)) {
+                let list = branch(out), next;
+                for (let i = list.length - 1; i >= 0; i--) {
+                    if (!hidden.has(list[i].id)) {
+                        next = list[i];
+                        break;
+                    }
+                }
+                if (!next) {
+                    let inner = visible(list);
+                    return inner[inner.length - 1] ?? out;
+                }
+                out = next;
+            }
+            return out;
+        },
+        open: (row) => fold(row, true),
+        row: (element) => element[SEGMENT] ?? element[ROW],
+        top: !roots,
+        viewport: () => viewport
+    }), focused = signal(cursor?.key ?? 0), quiet = null, tip = tooltip.shared({ delay: { open: TOOLTIP }, direction: 'e' }), typed = '', typedAt = 0, ui = new ReactiveObject_187wopb2(opened > 0, ''), selection = new Selection((ids) => {
+        state.selection = ids;
+    }), slot = new template_u1.VirtualSlot(rows, (row) => {
+        if (row.notice) {
+            return placeholder(row.notice, {
+                'aria-level': String(row.depth + 1),
+                class: [
+                    () => signal.selector(focused, row.key) && 'file-tree-row--focused',
+                    () => revealing.has(row) && ui.motion === 'open' && 'file-tree-row--reveal'
+                ],
+                id: `${id}-${row.key}`,
+                onclick: () => {
+                    focus(row);
+                    retry(row);
+                },
+                style: `--depth: ${row.depth}; --guides: ${guides(row.depth)}; --reveal-index: ${revealing.get(row) ?? 0};`
+            }, dragging?.row(row) ?? {}, onscreen(row));
+        }
+        let mark = decorations ? track(row.id) : null, open = row.open;
+        return (() => {
+            let root_187wopb3 = template_187wopb4(), element_187wopb5 = root_187wopb3.firstChild;
+            template_u1.slot(element_187wopb5, contents(row, mark, false), 1);
+            template_u1.setProperty(element_187wopb5, 'aria-level', row.depth + 1);
+            template_u1.setList(element_187wopb5, 'class', row.locked && '--disabled');
+            template_u1.setList(element_187wopb5, 'class', header(row) && 'file-tree-row--root');
+            template_u1.setList(element_187wopb5, 'class', () => active(row) && '--active');
+            template_u1.setList(element_187wopb5, 'class', () => holds(row, (id) => clipboard.marked.read(id)) && 'file-tree-row--cut');
+            template_u1.setList(element_187wopb5, 'class', () => holds(row, (id) => selection.read(id)) && !active(row) && 'file-tree-row--selected');
+            template_u1.setProperty(element_187wopb5, 'id', template_u1.interpolate([(id), "-", (row.key)]));
+            template_u1.setList(element_187wopb5, 'style', template_u1.interpolate(["--depth: ", (row.depth)]));
+            template_u1.setList(element_187wopb5, 'style', template_u1.interpolate([" --guides: ", (guides(row.depth))]));
+            template_u1.setList(element_187wopb5, 'style', template_u1.interpolate([" --reveal-index: ", (revealing.get(row) ?? 0)]));
+            template_u1.setProperties(element_187wopb5, row.locked && { 'aria-disabled': 'true' });
+            template_u1.setProperties(element_187wopb5, open && { 'aria-expanded': () => read(open) ? 'true' : 'false' });
+            template_u1.setProperties(element_187wopb5, mark && { class: () => read(mark).tone && `file-tree-row--${read(mark).tone}` });
+            template_u1.setProperties(element_187wopb5, search && { class: () => found('file-tree-row', matched(row)) });
+            template_u1.setProperties(element_187wopb5, !!row.scope && { class: 'file-tree-row--scope', style: `--scope: ${row.scope}` });
+            template_u1.setProperties(element_187wopb5, dragging?.row(row));
+            template_u1.setProperties(element_187wopb5, onscreen(row));
+            template_u1.setProperty(element_187wopb5, 'aria-label', mark ? () => read(mark).label : spoken({ ...row.element, name: caption(row), root: header(row) }));
+            template_u1.setProperty(element_187wopb5, 'aria-posinset', () => position(row));
+            template_u1.setProperty(element_187wopb5, 'aria-selected', () => holds(row, (id) => selection.read(id)) ? 'true' : 'false');
+            template_u1.setProperty(element_187wopb5, 'aria-setsize', () => row.size - read(row.gaps));
+            template_u1.setList(element_187wopb5, 'class', [
+                () => signal.selector(focused, row.key) && 'file-tree-row--focused',
+                () => signal.selector(sweep, row.key) && ui.motion === 'close' && 'file-tree-row--motion',
+                () => revealing.has(row) && ui.motion === 'open' && 'file-tree-row--reveal'
+            ]);
+            template_u1.delegate(element_187wopb5, 'auxclick', (event) => press(row, event));
+            template_u1.delegate(element_187wopb5, 'click', (event) => press(row, event));
+            template_u1.delegate(element_187wopb5, 'dblclick', (event) => press(row, event));
+            return root_187wopb3;
+        })();
+    }), pins = stick(rows, sticky, (row) => {
+        let mark = decorations ? track(row.id) : null;
+        return (() => {
+            let root_187wopbe = template_187wopbf(), element_187wopbg = root_187wopbe.firstChild;
+            template_u1.slot(element_187wopbg, contents(row, mark, true), 1);
+            template_u1.setList(element_187wopbg, 'class', row.locked && '--disabled');
+            template_u1.setList(element_187wopbg, 'class', header(row) && 'file-tree-row--root');
+            template_u1.setList(element_187wopbg, 'class', () => active(row) && 'file-tree-row--selected');
+            template_u1.setList(element_187wopbg, 'style', template_u1.interpolate(["--depth: ", (row.depth)]));
+            template_u1.setList(element_187wopbg, 'style', template_u1.interpolate([" --guides: ", (guides(row.depth))]));
+            template_u1.setProperties(element_187wopbg, mark && { class: () => read(mark).tone && `file-tree-row--${read(mark).tone}` });
+            template_u1.setList(element_187wopbg, 'class', () => signal.selector(focused, row.key) && 'file-tree-row--focused');
+            template_u1.delegate(element_187wopbg, 'click', () => unpin(row));
+            return root_187wopbe;
+        })();
+    }, height), anchor = null, detach, forget, motion = 0, root, timer, touched = null, unsubscribe, unwatch, viewport;
+    selection.replace([...(untrack(() => state.selection) ?? []), ...(chosen ? [chosen] : [])]);
+    persist();
+    function about(row) {
+        return () => {
+            let element = row.element, full = path(row), meta = [];
+            if (element.size !== undefined) {
+                meta.push(bytes(element.size));
+            }
+            if (element.modified !== undefined) {
+                meta.push(dates.format(element.modified));
+            }
+            return (() => {
+                let root_187wopb6 = template_187wopb7(), element_187wopb8 = root_187wopb6.firstChild.firstChild, element_187wopb9 = root_187wopb6.firstChild.firstElementChild, element_187wopba = root_187wopb6.firstChild.nextSibling;
+                template_u1.slot(element_187wopb8, full.slice(0, full.length - element.name.length));
+                template_u1.slot(element_187wopb9, element.name, 1);
+                template_u1.slot(element_187wopba, meta.length > 0 && (() => {
+                    let root_187wopbb = template_187wopbc(), element_187wopbd = root_187wopbb.firstChild;
+                    template_u1.slot(element_187wopbd, meta.join(' · '), 1);
+                    return root_187wopbb;
+                })());
+                return root_187wopb6;
+            })();
+        };
+    }
+    controller?.({
+        collapseAll: () => all(false),
+        expandAll: () => all(true),
+        find: (text) => search?.open(text),
+        next: (kind) => jump(kind, 1),
+        previous: (kind) => jump(kind, -1),
+        search: (text) => search?.set(text)
+    });
+    function activate(row, open, toggle = true, subject = segment(row)) {
+        if (row.notice) {
+            retry(row);
+            return;
+        }
+        if (row.locked) {
+            return;
+        }
+        clearTimeout(timer);
+        anchor = row;
+        selection.replace([subject.id]);
+        state.selected = subject.id;
+        select?.(subject.element);
+        if (!row.open) {
+            view?.(row.element, open);
+        }
+        else if (toggle) {
+            fold(row, !peek(row.open));
+        }
+    }
+    function active(row) {
+        return holds(row, (id) => signal.selector(current, id));
+    }
+    function all(value, scope) {
+        let at = scope ? rows.indexOf(scope) : -1;
+        if (scope && (!scope.open || scope.locked || at === -1)) {
+            return;
+        }
+        settle();
+        let count = scope ? (peek(scope.open) ? visible(branch(scope)).length : 0) : rows.$length, stack = scope ? [scope] : [...top];
+        while (stack.length) {
+            let row = stack.pop();
+            if (!row.open) {
+                continue;
+            }
+            let open = value && !row.locked && (header(row) || !!row.element.children?.length);
+            if (peek(row.open) !== open) {
+                write(row.open, open);
+                opened += open ? 1 : -1;
+            }
+            if (!open && loader?.forget(row.id)) {
+                row.children = null;
+            }
+            let children = open ? branch(row) : (row.children ?? []);
+            for (let i = 0, n = children.length; i < n; i++) {
+                stack.push(children[i]);
+            }
+        }
+        swap(at + 1, at + 1 + count, scope ? (peek(scope.open) ? visible(branch(scope)) : []) : visible(top));
+        prune();
+        ui.any = opened > 0;
+        if (cursor) {
+            focus(shown(cursor));
+        }
+        persist();
+    }
+    function begin(action, target) {
+        close(false);
+        if (target) {
+            reveal(target, true);
+        }
+        let row = target === null ? null : target === undefined ? cursor && segment(cursor) : built.get(target);
+        if (row === undefined) {
+            return;
+        }
+        if (row?.host) {
+            row = separate(row);
+        }
+        if (action === 'rename') {
+            if (!rename || !row || row.locked || header(row)) {
+                return;
+            }
+            write(draft, {
+                busy: signal(false),
+                element: row.element,
+                from: row,
+                kind: folder(row.element) ? 'folder' : 'file',
+                message: signal(''),
+                parent: row.parent,
+                range: null,
+                row,
+                value: row.element.name
+            });
+            move(rows.indexOf(row), 'end');
+            return;
+        }
+        if (!create) {
+            return;
+        }
+        let parent = row?.open && !row.locked ? row : (row?.parent ?? (roots ? top[0] ?? null : null)), stub = {
+            children: null,
+            depth: parent ? parent.depth + 1 : 0,
+            element: { id: `${id}-draft`, name: '', type: action },
+            gaps: signal(0),
+            id: `${id}-draft`,
+            key: ++key,
+            locked: false,
+            open: action === 'folder' ? signal(false) : null,
+            parent,
+            position: 1,
+            scope: parent?.scope ?? '',
+            size: (parent ? branch(parent) : top).length + 1
+        };
+        if (roots && !parent) {
+            return;
+        }
+        write(draft, {
+            busy: signal(false),
+            element: null,
+            from: cursor,
+            kind: action,
+            message: signal(''),
+            parent,
+            range: null,
+            row: stub,
+            value: ''
+        });
+        if (parent && !peek(parent.open)) {
+            expand(parent, true);
+        }
+        else {
+            rows.splice(parent ? rows.indexOf(parent) + 1 : 0, 0, stub);
+        }
+        move(rows.indexOf(stub), 'end');
+    }
+    function blank(root) {
+        let row = notes.get(root.id);
+        if (!row || row.parent !== root) {
+            notes.set(root.id, row = notice(root, { type: 'empty' }));
+        }
+        return row;
+    }
+    function branch(row) {
+        return row.children ??= loader && !row.element.children
+            ? [notice(row, loader.request(row.element))]
+            : build(row.element.children ?? [], row.depth + 1, row);
+    }
+    function build(elements, depth, parent) {
+        let arranged = compare && !(roots && !parent) ? [...elements].sort(compare) : elements, gaps = group(arranged, parent), n = arranged.length, out = new Array(n), prefix = scopes.length && parent ? `${path(parent)}/` : '', unseen = 0;
+        if (roots) {
+            prefix = prefix.slice(prefix.indexOf('/') + 1);
+        }
+        for (let i = 0; i < n; i++) {
+            let element = arranged[i], full = roots && !parent ? '' : prefix + element.name, merged = false, segments = [], tint = scopes.length ? scope(element, full, parent?.scope ?? '') : '';
+            if (hidden.has(element.id)) {
+                unseen++;
+            }
+            for (let next = joined(element); next; next = joined(element)) {
+                let previous = built.get(element.id);
+                merged ||= !!previous?.open && !previous.host && peek(previous.open);
+                segments.push(lay({ depth, element, gaps, parent, position: i + 1, scope: tint, segments: undefined, size: n }, true));
+                element = next;
+                full = `${full}/${element.name}`;
+                tint = scopes.length ? scope(element, full, tint) : '';
+            }
+            let fresh = !built.has(element.id), row = out[i] = lay({
+                depth,
+                element,
+                gaps,
+                parent,
+                position: i + 1,
+                scope: tint,
+                segments: segments.length ? segments : undefined,
+                size: n
+            }, false);
+            for (let j = 0, m = segments.length; j < m; j++) {
+                segments[j].host = row;
+            }
+            if (merged && fresh && !peek(row.open)) {
+                write(row.open, true);
+                opened++;
+            }
+        }
+        write(gaps, unseen);
+        return out;
+    }
+    function carry(row, layout) {
+        let element = layout.element;
+        if (row.element === element && row.depth === layout.depth && row.gaps === layout.gaps && row.scope === layout.scope && same(row.segments, layout.segments)) {
+            row.parent = layout.parent;
+            row.position = layout.position;
+            row.segments = layout.segments;
+            row.size = layout.size;
+            return row;
+        }
+        let next = {
+            ...row,
+            ...layout,
+            children: null,
+            key: ++key,
+            locked: element.selectable === false
+        };
+        built.set(row.id, next);
+        retarget(row, next);
+        return next;
+    }
+    function change(value) {
+        let edit = peek(draft);
+        edit.value = value;
+        write(edit.message, inspect(edit).message);
+    }
+    function close(refocus) {
+        let edit = peek(draft);
+        if (!edit) {
+            return;
+        }
+        write(draft, null);
+        if (!edit.element) {
+            let at = rows.indexOf(edit.row);
+            if (at !== -1) {
+                rows.splice(at, 1);
+            }
+        }
+        let back = edit.from ? rows.indexOf(edit.from) : -1;
+        move(back === -1 ? 0 : back, 'end');
+        if (split) {
+            let rejoin = split;
+            split = null;
+            update([rejoin]);
+        }
+        if (refocus) {
+            viewport?.focus({ preventScroll: true });
+        }
+    }
+    function commit(refocus) {
+        let edit = peek(draft);
+        if (!edit || peek(edit.busy)) {
+            return;
+        }
+        let element = edit.element;
+        if (element && edit.value === element.name) {
+            close(refocus);
+            return;
+        }
+        let { message, parent, parts } = inspect(edit);
+        if (message) {
+            write(edit.message, message);
+            return;
+        }
+        write(edit.busy, true);
+        Promise.resolve()
+            .then(() => element ? rename(element, edit.value) : create(parent, parts, edit.kind))
+            .then((accepted) => {
+            if (peek(draft) !== edit) {
+                return;
+            }
+            write(edit.busy, false);
+            if (accepted !== false) {
+                close(refocus);
+            }
+        }, (error) => {
+            if (peek(draft) !== edit) {
+                return;
+            }
+            write(edit.busy, false);
+            write(edit.message, error instanceof Error ? error.message : String(error));
+        });
+    }
+    function conceal(row) {
+        let at = rows.indexOf(row);
+        if (at === -1) {
+            return;
+        }
+        rows.splice(at, 1 + (row.open && peek(row.open) ? visible(branch(row)).length : 0));
+        prune();
+        if (cursor && rows.indexOf(cursor) === -1 && rows.$length) {
+            focus(rows[Math.min(at, rows.$length - 1)]);
+        }
+    }
+    function contents(row, mark, pinned) {
+        let element = row.element, open = row.open;
+        return (() => {
+            let root_187wopbh = template_187wopbi(), element_187wopbj = root_187wopbh.firstChild, element_187wopbk = element_187wopbj.nextSibling, element_187wopbl = element_187wopbk.nextSibling, element_187wopbm = element_187wopbl.nextSibling, element_187wopbn = element_187wopbm.nextSibling, element_187wopbo = element_187wopbn.nextSibling;
+            template_u1.slot(element_187wopbj, open && icon({ class: 'file-tree-chevron' }, remap.chevron ?? chevron), 1);
+            new template_u1.EffectSlot(element_187wopbk, () => !header(row) && render(element, open !== null && read(open)));
+            new template_u1.EffectSlot(element_187wopbl, () => {
+                let edit = read(draft);
+                if (pinned || edit?.row !== row) {
+                    return row.segments
+                        ? segments(row, (node) => [
+                            {
+                                class: [
+                                    () => node !== row && signal.selector(current, node.id) && '--active',
+                                    search && (() => found('file-tree-segment', search.mark(node.id)))
+                                ]
+                            },
+                            dragging?.segment(node) ?? {}
+                        ], (node) => () => emphasis(node.element.name, read(query) || read(given)))
+                        : (() => {
+                            let root_187wopbp = template_187wopbq(), element_187wopbr = root_187wopbp.firstChild;
+                            new template_u1.EffectSlot(element_187wopbr, () => emphasis(element.name, read(query) || read(given)), 1);
+                            return root_187wopbp;
+                        })();
+                }
+                return (() => {
+                    let root_187wopbs = template_187wopbt(), element_187wopbu = root_187wopbs.firstChild, element_187wopbv = element_187wopbu.nextSibling;
+                    template_u1.slot(element_187wopbu, row.segments && (() => {
+                        let root_187wopbw = template_187wopbq(), element_187wopbx = root_187wopbw.firstChild;
+                        template_u1.slot(element_187wopbx, row.segments.map((node) => `${node.element.name}/`).join(''), 1);
+                        return root_187wopbw;
+                    })());
+                    template_u1.slot(element_187wopbv, field(edit, id, {
+                        blur: leave,
+                        cancel: () => close(true),
+                        input: change,
+                        submit: () => commit(true)
+                    }));
+                    return root_187wopbs;
+                })();
+            });
+            template_u1.slot(element_187wopbm, element.symlink && icon({ 'aria-hidden': 'true', class: 'file-tree-marker' }, remap.symlink ?? symlink));
+            template_u1.slot(element_187wopbn, element.readonly && icon({ 'aria-hidden': 'true', class: 'file-tree-marker' }, remap.lock ?? lock));
+            template_u1.slot(element_187wopbo, mark && (() => {
+                let root_187wopby = template_187wopbz(), element_187wopb10 = root_187wopby.firstChild;
+                new template_u1.EffectSlot(element_187wopb10, () => read(mark).parts.map(chip), 1);
+                return root_187wopby;
+            })());
+            return root_187wopbh;
+        })();
+    }
+    function decorate(ids) {
+        let outer = touched === null, toggled = [];
+        touched ??= new Set();
+        for (let id of ids) {
+            let hide = unseen(id), parent = index.get(id)?.parent ?? null, silent = gone(id) && (filtered.has(id) || !deleted(id)), after = silent ? -1 : rank(decorations?.get(id)), before = own.get(id) ?? -1;
+            if (hide !== hidden.has(id)) {
+                obscure(id, hide);
+                toggled.push(id);
+            }
+            if (after !== before) {
+                if (after === -1) {
+                    own.delete(id);
+                }
+                else {
+                    own.set(id, after);
+                }
+                let from = lift(before), to = lift(after);
+                if (from !== to) {
+                    tally(parent, from, undefined, -1);
+                    tally(parent, to, undefined, 1);
+                }
+            }
+            let decoration = silent ? undefined : decorations?.get(id), lines = [decoration?.additions ?? 0, decoration?.deletions ?? 0], previous = diffs.get(id), added = lines[0] - (previous?.[0] ?? 0), removed = lines[1] - (previous?.[1] ?? 0);
+            if (added || removed) {
+                if (lines[0] || lines[1]) {
+                    diffs.set(id, lines);
+                }
+                else {
+                    diffs.delete(id);
+                }
+                tally(parent, 0, [added, removed], 1);
+            }
+            refresh(id);
+        }
+        if (toggled.length === 1) {
+            let id = toggled[0], groups = refold(id), row = built.get(id);
+            if (groups.length) {
+                update(groups);
+            }
+            else if (row && hidden.has(id)) {
+                conceal(row);
+            }
+            else if (row) {
+                restore(row);
+            }
+        }
+        else if (toggled.length) {
+            reshow(toggled);
+        }
+        if (outer) {
+            let marked = touched;
+            touched = null;
+            for (let id of marked) {
+                refresh(id);
+            }
+        }
+    }
+    function deleted(id) {
+        let decoration = decorations?.get(id);
+        return (decoration?.status ?? decoration?.staged) === 'deleted';
+    }
+    function copy(element, limit, container, scroller) {
+        let edge = element.getBoundingClientRect().bottom, frame = container.getBoundingClientRect(), out = [], view = scroller.getBoundingClientRect(), left = view.left + scroller.clientLeft, top = view.top + scroller.clientTop, bottom = top + scroller.clientHeight;
+        stage.edge = edge - top;
+        stage.height = scroller.clientHeight;
+        stage.left = left - frame.left - container.clientLeft;
+        stage.top = top - frame.top - container.clientTop;
+        stage.width = scroller.clientWidth;
+        for (let i = 0, node = element.nextElementSibling; i < limit && node?.classList.contains('file-tree-row'); i++, node = node.nextElementSibling) {
+            let rect = node.getBoundingClientRect(), row = node[ROW];
+            if (rect.top >= bottom) {
+                break;
+            }
+            if (row) {
+                out.push({ left: rect.left - left, row, top: rect.top - edge, width: rect.width });
+            }
+        }
+        return out;
+    }
+    function destination(row) {
+        return row.open ? row.element : (row.parent?.element ?? null);
+    }
+    async function discard(elements, permanent) {
+        if (!elements.length || (operations?.confirm && !(await operations.confirm(elements, permanent)))) {
+            return;
+        }
+        operations?.delete?.(elements, permanent);
+    }
+    function expand(row, value, inner) {
+        if (!row.open || peek(row.open) === value) {
+            return;
+        }
+        settle();
+        let at = rows.indexOf(row);
+        if (value) {
+            write(row.open, true);
+            opened++;
+            if (at !== -1) {
+                insert(at + 1, inner ?? visible(branch(row)));
+            }
+        }
+        else {
+            if (at !== -1) {
+                rows.splice(at + 1, (inner ?? visible(branch(row))).length);
+            }
+            write(row.open, false);
+            opened--;
+            prune();
+            if (loader?.forget(row.id)) {
+                row.children = null;
+            }
+            if (cursor) {
+                focus(shown(cursor));
+            }
+        }
+        ui.any = opened > 0;
+        persist();
+    }
+    function flip(row) {
+        if (row.locked) {
+            return;
+        }
+        anchor = row;
+        if (!selection.has(row.id)) {
+            selection.replace([...selection.ids, row.id]);
+            primary(row.id);
+            prune();
+            return;
+        }
+        let rest = [...selection.ids].filter((id) => id !== row.id);
+        selection.replace(rest);
+        if (state.selected === row.id) {
+            primary(rest[rest.length - 1] ?? '');
+        }
+    }
+    function fold(row, value) {
+        if (!row.open || peek(row.open) === value) {
+            return;
+        }
+        settle();
+        let container = root, element = node(row), inner = visible(branch(row)), scroller = viewport;
+        if (!container || !element || !inner.length || !scroller) {
+            expand(row, value);
+            return;
+        }
+        if (value) {
+            for (let i = 0, n = inner.length; i < n; i++) {
+                revealing.set(inner[i], i);
+            }
+        }
+        let measured = copy(element, value ? Infinity : inner.length, container, scroller);
+        expand(row, value, inner);
+        motion = requestAnimationFrame(() => {
+            let out = [];
+            for (let i = 0, n = measured.length; i < n; i++) {
+                let current = lookup(measured[i].row.id);
+                if (!current || !node(current)) {
+                    out.push(measured[i]);
+                }
+            }
+            ghosts.push(...out);
+            write(sweep, row.key);
+            ui.motion = value ? 'open' : 'close';
+            ui.motionRows = inner.length;
+        });
+    }
+    function focus(row) {
+        cursor = row;
+        write(focused, row.key);
+    }
+    function follow(row) {
+        clearTimeout(timer);
+        if (preview && !row.open && !row.locked) {
+            if (preview === 'immediate') {
+                activate(row, PREVIEW);
+            }
+            else {
+                timer = setTimeout(() => activate(row, PREVIEW), REST);
+            }
+        }
+    }
+    function ghost({ left, row, top, width }) {
+        let style = `--depth: ${row.depth}; --guides: ${guides(row.depth)}; left: ${left}px; margin: 0; position: absolute; top: ${top}px; width: ${width}px;`;
+        if (row.notice) {
+            return placeholder(row.notice, { style });
+        }
+        let mark = decorations ? track(row.id) : null, open = row.open;
+        return (() => {
+            let root_187wopb11 = template_187wopb12(), element_187wopb13 = root_187wopb11.firstChild;
+            template_u1.slot(element_187wopb13, contents(row, mark, true), 1);
+            template_u1.setList(element_187wopb13, 'class', row.locked && '--disabled');
+            template_u1.setList(element_187wopb13, 'class', header(row) && 'file-tree-row--root');
+            template_u1.setList(element_187wopb13, 'class', () => active(row) && '--active');
+            template_u1.setList(element_187wopb13, 'class', () => holds(row, (id) => clipboard.marked.read(id)) && 'file-tree-row--cut');
+            template_u1.setList(element_187wopb13, 'class', () => holds(row, (id) => selection.read(id)) && !active(row) && 'file-tree-row--selected');
+            template_u1.setList(element_187wopb13, 'style', style);
+            template_u1.setProperties(element_187wopb13, open && { 'aria-expanded': () => read(open) ? 'true' : 'false' });
+            template_u1.setProperties(element_187wopb13, mark && { class: () => read(mark).tone && `file-tree-row--${read(mark).tone}` });
+            template_u1.setProperties(element_187wopb13, search && { class: () => found('file-tree-row', matched(row)) });
+            template_u1.setProperties(element_187wopb13, !!row.scope && { class: 'file-tree-row--scope', style: `--scope: ${row.scope}` });
+            template_u1.setList(element_187wopb13, 'class', () => signal.selector(focused, row.key) && 'file-tree-row--focused');
+            return root_187wopb11;
+        })();
+    }
+    function gone(id) {
+        return filtered.has(id) || (deleted(id) && !display.deleted) || (display.ignored === false && decorations?.get(id)?.status === 'ignored');
+    }
+    function group(elements, parent) {
+        let owner = parent?.id ?? null;
+        for (let i = 0, n = elements.length; i < n; i++) {
+            let row = built.get(elements[i].id);
+            if (row && (row.parent?.id ?? null) === owner) {
+                return row.gaps;
+            }
+        }
+        return signal(0, () => false);
+    }
+    function header(row) {
+        return roots && row.parent === null;
+    }
+    function height() {
+        return viewport?.querySelector('.file-tree-row')?.offsetHeight ?? 0;
+    }
+    function informative(row, target) {
+        let element = row.element, name = target.querySelector('.file-tree-name');
+        if (element.size !== undefined || element.modified !== undefined || !name) {
+            return true;
+        }
+        return name.scrollWidth > name.clientWidth || path(row) !== name.textContent?.trim();
+    }
+    function insert(at, items) {
+        for (let i = 0, n = items.length; i < n; i += CHUNK) {
+            rows.splice(at + i, 0, ...items.slice(i, i + CHUNK));
+        }
+    }
+    function inspect(edit) {
+        let parent = edit.parent?.element ?? null, result = resolve(edit.value, parent, edit.element, siblings, folder);
+        if (!result.message && validate) {
+            result.message = validate(edit.value, parent, edit.element) || '';
+        }
+        return result;
+    }
+    function joined(element) {
+        if (!compact || element.id === split || hidden.has(element.id) || !folder(element) || (roots && index.get(element.id)?.parent === null)) {
+            return null;
+        }
+        return sole(element, hidden, folder);
+    }
+    async function jump(kind, step) {
+        if (!decorations) {
+            return null;
+        }
+        if (loader) {
+            await uncover(kind);
+        }
+        let found = [];
+        for (let id of decorations.keys()) {
+            let entry = index.get(id);
+            if (!entry || folder(entry.element) || hidden.has(id) || !flagged(decorations.get(id), kind)) {
+                continue;
+            }
+            let row = locate(id);
+            found.push({ place: place(row), row });
+        }
+        found.sort((a, b) => order(a.place, b.place));
+        let at = seek(found.map((item) => item.place), cursor ? place(cursor) : null, step);
+        if (at === -1) {
+            return null;
+        }
+        let target = found[at].row;
+        reveal(target.id, true);
+        follow(target);
+        return target.element;
+    }
+    function lay(layout, folded) {
+        let element = layout.element, previous = built.get(element.id);
+        if (!previous) {
+            let open = folder(element) ? folded || initial.has(element.id) : null, row = {
+                ...layout,
+                children: null,
+                id: element.id,
+                key: ++key,
+                locked: element.selectable === false,
+                open: open === null ? null : signal(open)
+            };
+            if (open && !folded) {
+                opened++;
+            }
+            built.set(element.id, row);
+            return row;
+        }
+        let was = !!previous.host, row = carry(previous, layout);
+        row.host = undefined;
+        if (was !== folded) {
+            row.children = null;
+            if (!folded) {
+                opened += peek(row.open) ? 1 : 0;
+            }
+            else if (peek(row.open)) {
+                opened--;
+            }
+            else {
+                write(row.open, true);
+            }
+        }
+        if (row !== previous) {
+            refresh(element.id);
+        }
+        return row;
+    }
+    function leave() {
+        let edit = peek(draft);
+        if (!edit || peek(edit.busy)) {
+            return;
+        }
+        if (peek(edit.message) || inspect(edit).message) {
+            close(false);
+        }
+        else {
+            commit(false);
+        }
+    }
+    function loaded(id, children) {
+        let element = model.get(id);
+        if (!element) {
+            return;
+        }
+        if (children && !element.children) {
+            model.add(children, id);
+        }
+        else {
+            update([id]);
+        }
+    }
+    function locate(id) {
+        let chain = [];
+        for (let node = index.get(id)?.parent ?? null; node !== null; node = index.get(node).parent) {
+            chain.push(node);
+        }
+        for (let i = chain.length - 1; i >= 0; i--) {
+            let row = built.get(chain[i]);
+            if (!row.host) {
+                branch(row);
+            }
+        }
+        let row = built.get(id);
+        return row?.host ?? row;
+    }
+    function look(id) {
+        let entry = index.get(id), inside = -1, list = counts.get(id);
+        if (list) {
+            for (let i = list.length - 1; i > 0; i--) {
+                if (list[i]) {
+                    inside = i;
+                    break;
+                }
+            }
+        }
+        let decoration = decorations?.get(id), highest = Math.max(own.get(id) ?? -1, inside), mine = diffs.get(id), total = totals.get(id), lines = display.stats ? [(mine?.[0] ?? 0) + (total?.[0] ?? 0), (mine?.[1] ?? 0) + (total?.[1] ?? 0)] : [0, 0], row = built.get(id), subject = entry?.element ?? { name: id }, label = spoken({ ...subject, name: row?.segments ? caption(row) : subject.name, root: roots && entry?.parent === null }, decoration, lines, inside > 0 ? RANK[inside] : undefined), parts = badge(decoration, lines, entry && folder(entry.element) ? (highest > 0 ? RANK[highest] : '') : null), tone = highest === -1 ? '' : RANK[highest];
+        return { key: JSON.stringify([label, parts]), label, parts, tone };
+    }
+    function lookup(id) {
+        return built.get(id) ?? rows.find((row) => row.notice && row.id === id);
+    }
+    function matched(row) {
+        let out = false;
+        for (let node of lineage(row)) {
+            let mark = search.mark(node.id);
+            if (mark === 'current') {
+                return mark;
+            }
+            out ||= mark;
+        }
+        return out;
+    }
+    function modes() {
+        return [display.deleted, display.dotfiles, display.ignored, display.stats].join();
+    }
+    function move(index, align) {
+        let row = rows[index];
+        if (!row || !viewport) {
+            return;
+        }
+        focus(row);
+        let element = node(row);
+        if (!element) {
+            slot.scrollTo(align === 'start' ? index - pins.cover(row) : index, align);
+            return;
+        }
+        let r = element.getBoundingClientRect(), v = viewport.getBoundingClientRect(), top = v.top + pins.cover(row) * r.height;
+        if (r.top < top) {
+            viewport.scrollTop -= top - r.top;
+        }
+        else if (r.bottom > v.bottom) {
+            viewport.scrollTop += r.bottom - v.bottom;
+        }
+    }
+    function notice(parent, value) {
+        let at = ++key, self = `${id}-${at}`;
+        return {
+            children: null,
+            depth: parent.depth + 1,
+            element: { id: self, name: '' },
+            gaps: signal(0),
+            id: self,
+            key: at,
+            locked: true,
+            notice: value,
+            open: null,
+            parent,
+            position: 1,
+            scope: parent.scope,
+            size: 1
+        };
+    }
+    function node(row) {
+        return document.getElementById(`${id}-${row.key}`);
+    }
+    function obscure(id, value) {
+        let row = built.get(id);
+        if (value) {
+            hidden.add(id);
+        }
+        else {
+            hidden.delete(id);
+        }
+        shifts++;
+        if (row) {
+            write(row.gaps, peek(row.gaps) + (value ? 1 : -1));
+        }
+    }
+    function onscreen(row) {
+        return {
+            onconnect: (element) => {
+                element[ROW] = row;
+            }
+        };
+    }
+    function owner(element) {
+        let row = element?.[ROW];
+        return row && !row.notice ? row : null;
+    }
+    function page() {
+        let size = height();
+        return size && viewport ? Math.max(1, Math.floor(viewport.clientHeight / size)) : 1;
+    }
+    function perform(name, row) {
+        switch (name) {
+            case 'all': {
+                let ids = [];
+                for (let i = 0, n = rows.$length; i < n; i++) {
+                    if (!rows[i].locked) {
+                        ids.push(rows[i].id);
+                    }
+                }
+                selection.replace(ids);
+                if (!selection.has(state.selected) && !row.locked) {
+                    primary(row.id);
+                }
+                return true;
+            }
+            case 'clear': {
+                let cut = clipboard.cancel(), lead = row.locked ? built.get(state.selected) : row;
+                if (!cut && selection.ids.size < 2) {
+                    return false;
+                }
+                selection.replace(lead ? [lead.id] : []);
+                if (lead) {
+                    anchor = lead;
+                    primary(lead.id);
+                }
+                return true;
+            }
+            case 'copy':
+            case 'cut': {
+                let elements = targets(row, true);
+                if (!operations || !elements.length) {
+                    return false;
+                }
+                clipboard.hold(elements, name === 'cut');
+                operations[name]?.(elements);
+                return true;
+            }
+            case 'delete':
+            case 'trash':
+                if (!operations?.delete) {
+                    return false;
+                }
+                void discard(targets(row, true), name === 'delete');
+                return true;
+            case 'duplicate': {
+                let elements = targets(row, true);
+                if (!operations?.duplicate || !elements.length) {
+                    return false;
+                }
+                operations.duplicate(elements);
+                return true;
+            }
+            case 'paste': {
+                let paste = operations?.paste, target = destination(segment(row));
+                if (!paste) {
+                    return false;
+                }
+                void clipboard.paste((elements, cut) => paste(elements, target, cut));
+                return true;
+            }
+            case 'path':
+            case 'relative': {
+                let elements = targets(row, false);
+                if (!elements.length) {
+                    return false;
+                }
+                void writeText(elements.map((element) => address(element, name === 'relative')).join('\n'));
+                return true;
+            }
+            case 'redo':
+            case 'undo':
+                if (!history || !(name === 'undo' ? history.canUndo : history.canRedo)) {
+                    return false;
+                }
+                void history[name]();
+                return true;
+            case 'toggle':
+                flip(row);
+                return true;
+        }
+    }
+    function persist() {
+        if (!snapshot) {
+            return;
+        }
+        let out = [];
+        for (let [id, row] of built) {
+            if (row.open && peek(row.open) && !unfolded.get(id)) {
+                out.push(id);
+            }
+        }
+        for (let id of initial) {
+            if (!built.has(id) && (loader || index.has(id))) {
+                out.push(id);
+            }
+        }
+        snapshot.expanded = out;
+    }
+    function position(row) {
+        let siblings = row.parent ? row.parent.children : top;
+        if (!read(row.gaps) || !siblings) {
+            return row.position;
+        }
+        let counted = places.get(siblings);
+        if (!counted || counted.at !== shifts) {
+            let before = new Int32Array(siblings.length + 1);
+            for (let i = 0, n = siblings.length; i < n; i++) {
+                before[i + 1] = before[i] + +hidden.has(siblings[i].id);
+            }
+            places.set(siblings, counted = { at: shifts, before });
+        }
+        return row.position - counted.before[row.position - 1];
+    }
+    function press(row, event) {
+        let from = cursor, subject = pick(row, event), type = event.type;
+        if (type === 'auxclick' && event.button !== 1) {
+            return;
+        }
+        focus(row);
+        if (type === 'click' && event.shiftKey) {
+            span(from ?? row, row);
+            return;
+        }
+        if (type === 'click' && (event.ctrlKey || event.metaKey)) {
+            flip(subject);
+            return;
+        }
+        if (!row.open) {
+            activate(row, { mode: type === 'click' ? 'preview' : 'pinned', side: event.altKey });
+            return;
+        }
+        let single = unfold === 'click' || twistie(event);
+        if (type === 'click' && event.altKey) {
+            activate(row, PREVIEW, false, subject);
+            all(!peek(row.open), row);
+        }
+        else if (type === 'click') {
+            activate(row, PREVIEW, single, subject);
+        }
+        else if (type === 'dblclick' && !single && !event.altKey && !row.locked) {
+            fold(row, !peek(row.open));
+        }
+    }
+    function primary(id) {
+        quiet = id;
+        state.selected = id;
+    }
+    function prune() {
+        selection.replace([...selection.ids].filter((id) => {
+            let row = built.get(id);
+            return id === state.selected || (!!row && !hidden.has(id) && shown(row) === row);
+        }));
+    }
+    function purge(ids) {
+        for (let i = 0, n = ids.length; i < n; i++) {
+            let id = ids[i], row = built.get(id);
+            if (row?.open && peek(row.open) && !row.host) {
+                opened--;
+            }
+            if (anchor?.id === id) {
+                anchor = null;
+            }
+            built.delete(id);
+            counts.delete(id);
+            diffs.delete(id);
+            filtered.delete(id);
+            hidden.delete(id);
+            initial.delete(id);
+            marks.delete(id);
+            notes.delete(id);
+            own.delete(id);
+            totals.delete(id);
+        }
+    }
+    function recover(at) {
+        if (cursor && rows.includes(cursor)) {
+            return;
+        }
+        let row;
+        for (let node = cursor && index.has(cursor.id) ? cursor.id : null; node !== null; node = index.get(node).parent) {
+            let found = built.get(node), candidate = found?.host ?? found;
+            if (candidate && rows.includes(candidate)) {
+                row = candidate;
+                break;
+            }
+        }
+        if (row) {
+            focus(row);
+        }
+        else if (rows.$length) {
+            focus(rows[Math.min(Math.max(at, 0), rows.$length - 1)]);
+        }
+        else {
+            cursor = null;
+            write(focused, 0);
+        }
+    }
+    function redisplay(force = false) {
+        settle();
+        let changed = [];
+        for (let id of index.keys()) {
+            rehide(id, changed);
+        }
+        for (let id of decorations?.keys() ?? []) {
+            if (!index.has(id)) {
+                rehide(id, changed);
+            }
+        }
+        decorate(changed);
+        for (let id of marks.keys()) {
+            refresh(id);
+        }
+        if (changed.length || force) {
+            reshow(changed);
+        }
+    }
+    function refold(id) {
+        let out = [];
+        for (let node of [id, index.get(id)?.parent ?? null]) {
+            let row = node === null ? undefined : built.get(node);
+            if (row && stale(row)) {
+                out.push((row.host ?? row).parent?.id ?? null);
+            }
+        }
+        return out;
+    }
+    function refresh(id) {
+        let mark = marks.get(id);
+        if (!mark) {
+            return;
+        }
+        if (touched) {
+            touched.add(id);
+            return;
+        }
+        let current = peek(mark), next = look(id);
+        if (current.key !== next.key || current.tone !== next.tone) {
+            write(mark, next);
+        }
+    }
+    function regroup(id) {
+        let row = id === null ? undefined : built.get(id);
+        return row && (row.host || stale(row)) ? (row.host ?? row).parent?.id ?? null : id;
+    }
+    function rehide(id, changed) {
+        let hide = unseen(id);
+        if (hide !== hidden.has(id)) {
+            obscure(id, hide);
+            changed.push(id);
+        }
+    }
+    function reshow(changed) {
+        settle();
+        for (let group of new Set(changed.flatMap(refold))) {
+            sync(group);
+        }
+        if (cursor?.host) {
+            focus(cursor.host);
+        }
+        let next = visible(top), kept = new Set(next), target = cursor && !kept.has(cursor)
+            ? rows.slice(rows.indexOf(cursor)).find((row) => kept.has(row)) ?? next[next.length - 1]
+            : undefined;
+        swap(0, rows.$length, next);
+        prune();
+        if (target) {
+            focus(target);
+        }
+        ui.any = opened > 0;
+        persist();
+    }
+    function restore(row) {
+        let parent = row.parent, at = parent ? rows.indexOf(parent) + 1 : 0;
+        if (parent && (!peek(parent.open) || at === 0)) {
+            return;
+        }
+        let siblings = parent ? branch(parent) : top;
+        for (let i = row.position - 2; i >= 0; i--) {
+            let sibling = siblings[i];
+            if (!hidden.has(sibling.id)) {
+                at = rows.indexOf(sibling) + 1 + (sibling.open && peek(sibling.open) ? visible(branch(sibling)).length : 0);
+                break;
+            }
+        }
+        insert(at, [row, ...(row.open && peek(row.open) ? visible(branch(row)) : [])]);
+    }
+    function restructure({ elements, from = null, ids, parent, type }) {
+        let groups = [];
+        seen = model.version;
+        if (type === 'remove') {
+            let edit = peek(draft), removed = new Set(ids);
+            if (edit && ((edit.element && removed.has(edit.element.id)) || (edit.parent && removed.has(edit.parent.id)))) {
+                close(false);
+            }
+            shift(ids, parent, null);
+            purge(ids);
+            if (removed.has(state.selected)) {
+                primary([...selection.ids].find((id) => !removed.has(id)) ?? '');
+            }
+        }
+        else {
+            for (let id of ids) {
+                filtered.delete(id);
+            }
+            for (let i = 0, n = elements.length; i < n; i++) {
+                recheck(elements[i], index, display.dotfiles !== false, excluded, roots, filtered);
+            }
+            for (let id of ids) {
+                if (roots && type === 'add' && index.get(id)?.parent === null) {
+                    initial.add(id);
+                }
+                if (unseen(id) === hidden.has(id)) {
+                    continue;
+                }
+                obscure(id, !hidden.has(id));
+                groups.push(...refold(id));
+            }
+            if (type === 'move') {
+                shift(ids, from, parent);
+            }
+            if (decorations) {
+                decorate(ids);
+            }
+        }
+        update([...(type === 'move' && from !== parent ? [from, parent] : [parent]), ...groups]);
+        search?.refresh();
+    }
+    function resync() {
+        close(false);
+        for (let [id, row] of built) {
+            if (index.has(id)) {
+                row.children = null;
+            }
+            else {
+                purge([id]);
+            }
+        }
+        filtered = filter(model.elements, display.dotfiles !== false, excluded, roots);
+        hidden = new Set([...filtered, ...(decorations?.keys() ?? [])].filter(gone));
+        shifts++;
+        if (decorations) {
+            counts.clear();
+            diffs.clear();
+            own.clear();
+            totals.clear();
+            for (let id of marks.keys()) {
+                refresh(id);
+            }
+        }
+        seen = model.version;
+        update([null]);
+    }
+    function retarget(row, next) {
+        let edit = peek(draft);
+        if (anchor === row) {
+            anchor = next;
+        }
+        if (cursor === row) {
+            focus(next);
+        }
+        if (!edit) {
+            return;
+        }
+        if (edit.from === row) {
+            edit.from = next;
+        }
+        if (edit.parent === row) {
+            edit.parent = next;
+            if (!edit.element) {
+                edit.row.parent = next;
+            }
+        }
+        if (edit.row === row) {
+            edit.element = next.element;
+            edit.row = next;
+        }
+    }
+    function retrace({ operations }) {
+        let ids = new Set(), left = null;
+        for (let i = 0, n = operations.length; i < n; i++) {
+            let operation = operations[i];
+            if (operation.type === 'remove') {
+                left ??= operation.parent;
+            }
+            else {
+                ids.add(operation.element.id);
+            }
+        }
+        if (!ids.size && left !== null) {
+            ids.add(left);
+        }
+        let found = [];
+        for (let id of ids) {
+            let row = locate(id);
+            if (row && !row.locked && !hidden.has(id)) {
+                found.push({ id, place: place(row), row });
+            }
+        }
+        if (!found.length) {
+            return;
+        }
+        found.sort((a, b) => order(a.place, b.place));
+        anchor = found[0].row;
+        selection.replace(found.map((item) => item.id));
+        primary(found[0].id);
+        reveal(found[0].id, true);
+    }
+    function retry(row) {
+        if (row.notice?.type === 'error' && loader?.forget(row.parent.id)) {
+            update([row.parent.id]);
+        }
+    }
+    function reveal(id, scroll) {
+        let row = locate(id);
+        if (!row) {
+            return;
+        }
+        for (let node = row.parent; node; node = node.parent) {
+            expand(node, true);
+        }
+        let at = rows.indexOf(row);
+        if (at === -1) {
+            return;
+        }
+        if (scroll) {
+            move(at, 'center');
+        }
+        else {
+            focus(row);
+        }
+    }
+    function scope(element, full, inherited) {
+        for (let i = 0, n = scopes.length; i < n; i++) {
+            let match = scopes[i].match;
+            if (typeof match === 'function' ? match(element) : match.test(full)) {
+                return scopes[i].color;
+            }
+        }
+        return inherited;
+    }
+    function segment(row) {
+        return row.segments?.find((node) => node.id === state.selected) ?? row;
+    }
+    function separate(row) {
+        split = row.id;
+        update([row.id]);
+        return built.get(row.id);
+    }
+    function settle() {
+        if (!motion) {
+            return;
+        }
+        cancelAnimationFrame(motion);
+        motion = 0;
+        ghosts.splice(0, ghosts.$length);
+        revealing.clear();
+        write(sweep, 0);
+        ui.motion = '';
+        flush();
+    }
+    function shift(ids, from, to) {
+        for (let i = 0, n = ids.length; i < n; i++) {
+            let lines = diffs.get(ids[i]), value = lift(own.get(ids[i]) ?? -1);
+            if (value > 0 || lines) {
+                tally(from, value, lines, -1);
+                tally(to, value, lines, 1);
+            }
+        }
+    }
+    function siblings(parent) {
+        return (parent ? parent.children ?? [] : model.elements).filter((element) => decorations?.get(element.id)?.status !== 'deleted');
+    }
+    function sift(folders) {
+        let changed = false, next = new Set(folders), shut = [], spared = new Set();
+        if (compact) {
+            for (let row of built.values()) {
+                if (row.open && !row.host && !peek(row.open)) {
+                    shut.push(row.id);
+                }
+            }
+        }
+        redisplay();
+        for (let i = 0, n = shut.length; i < n; i++) {
+            if (built.get(shut[i])?.host && !unfolded.has(shut[i])) {
+                unfolded.set(shut[i], true);
+            }
+        }
+        if (!folders) {
+            for (let row of [cursor, built.get(state.selected)]) {
+                for (let node of row ? ancestors(row) : []) {
+                    spared.add(node.id);
+                }
+            }
+        }
+        for (let [id, mine] of unfolded) {
+            if (next.has(id)) {
+                continue;
+            }
+            let row = built.get(id);
+            unfolded.delete(id);
+            if (!mine || spared.has(id) || !row?.open || !peek(row.open)) {
+                continue;
+            }
+            write(row.open, false);
+            opened -= row.host ? 0 : 1;
+            changed = true;
+        }
+        for (let id of folders ?? []) {
+            if (unfolded.has(id)) {
+                continue;
+            }
+            locate(id);
+            let row = built.get(id), open = !!row?.open && !row.host && !row.locked && !peek(row.open);
+            unfolded.set(id, open);
+            if (open) {
+                write(row.open, true);
+                opened++;
+                changed = true;
+            }
+        }
+        redisplay(changed);
+        ui.any = opened > 0;
+        persist();
+    }
+    function span(from, to) {
+        if (!anchor || rows.indexOf(anchor) === -1) {
+            anchor = from.locked ? to : from;
+        }
+        let a = rows.indexOf(anchor), b = rows.indexOf(to), ids = [];
+        for (let i = Math.min(a, b), n = Math.max(a, b); i <= n; i++) {
+            if (!rows[i].locked) {
+                ids.push(rows[i].id);
+            }
+        }
+        selection.replace(ids);
+        primary(anchor.locked ? (ids[0] ?? '') : anchor.id);
+    }
+    function stale(row) {
+        let now = joined(index.get(row.id)?.element ?? row.element), was = row.host ? lineage(row.host)[lineage(row).length] : undefined;
+        return (now?.id ?? null) !== (was?.id ?? null);
+    }
+    function swap(at, end, next) {
+        let head = 0, n = next.length, tail = 0;
+        while (head < n && at + head < end && rows[at + head] === next[head]) {
+            head++;
+        }
+        while (tail < n - head && tail < end - at - head && rows[end - tail - 1] === next[n - tail - 1]) {
+            tail++;
+        }
+        let items = next.slice(head, n - tail), removed = end - at - head - tail;
+        if (!items.length && !removed) {
+            return;
+        }
+        rows.splice(at + head, removed, ...items.slice(0, CHUNK));
+        insert(at + head + CHUNK, items.slice(CHUNK));
+    }
+    function sync(target) {
+        let row = target === null ? null : built.get(target);
+        if (row === undefined || (row && !row.children)) {
+            return;
+        }
+        let next;
+        if (row) {
+            row.children = null;
+            next = branch(row);
+        }
+        else {
+            next = top = build(model.elements, 0, null);
+        }
+        let at = row ? rows.indexOf(row) + 1 : 0, end = row ? at : rows.$length;
+        if (row && (at === 0 || !peek(row.open))) {
+            return;
+        }
+        while (row && end < rows.$length && rows[end].depth > row.depth) {
+            end++;
+        }
+        swap(at, end, visible(next));
+    }
+    function tally(start, value, lines, sign) {
+        if (value <= 0 && !lines) {
+            return;
+        }
+        for (let parent = start; parent !== null; parent = index.get(parent)?.parent ?? null) {
+            if (value > 0) {
+                let list = counts.get(parent);
+                if (!list) {
+                    counts.set(parent, list = new Array(RANK.length).fill(0));
+                }
+                list[value] += sign;
+            }
+            if (lines) {
+                let total = totals.get(parent);
+                if (!total) {
+                    totals.set(parent, total = [0, 0]);
+                }
+                total[0] += sign * lines[0];
+                total[1] += sign * lines[1];
+            }
+            refresh(parent);
+        }
+    }
+    function targets(row, distinct) {
+        let subject = segment(row);
+        if (!selection.has(subject.id)) {
+            return subject.locked || (distinct && header(subject)) ? [] : [subject.element];
+        }
+        let out = [];
+        for (let i = 0, n = rows.$length; i < n; i++) {
+            for (let candidate of lineage(rows[i])) {
+                if (!selection.has(candidate.id)) {
+                    continue;
+                }
+                if (distinct && (header(candidate) || ancestors(candidate).some((node) => selection.has(node.id) && !header(node)))) {
+                    continue;
+                }
+                out.push(candidate.element);
+            }
+        }
+        return out;
+    }
+    function track(id) {
+        let mark = marks.get(id);
+        if (!mark) {
+            marks.set(id, mark = signal(look(id)));
+        }
+        return mark;
+    }
+    function typeahead(character, from) {
+        let now = performance.now(), next = (now - typedAt > TYPEAHEAD ? '' : typed) + character.toLowerCase(), repeat = [...next].every((c) => c === next[0]), start = repeat ? from + 1 : from;
+        typed = repeat ? next[0] : next;
+        typedAt = now;
+        for (let i = 0, n = rows.$length; i < n; i++) {
+            let index = (start + i) % n;
+            if (caption(rows[index]).toLowerCase().startsWith(typed)) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    async function uncover(kind) {
+        let asked = new Set();
+        for (;;) {
+            let folders = [];
+            for (let id of decorations.keys()) {
+                if (index.has(id) || !flagged(decorations.get(id), kind)) {
+                    continue;
+                }
+                let parent = enclosing(id).find((candidate) => index.has(candidate)), element = parent === undefined ? undefined : index.get(parent).element;
+                if (!element || element.children || asked.has(element.id) || hidden.has(element.id) || !folder(element)) {
+                    continue;
+                }
+                asked.add(element.id);
+                folders.push(element);
+            }
+            if (!folders.length) {
+                return;
+            }
+            for (let i = 0, n = folders.length; i < n; i++) {
+                await loader.wait(folders[i]);
+            }
+        }
+    }
+    function unpin(row) {
+        move(rows.indexOf(row), 'start');
+        requestAnimationFrame(() => activate(row, PREVIEW));
+    }
+    function unseen(id) {
+        return gone(id) || !!search?.hides(id);
+    }
+    function update(folders) {
+        settle();
+        let at = cursor ? rows.indexOf(cursor) : 0;
+        for (let i = 0, n = folders.length; i < n; i++) {
+            sync(regroup(folders[i]));
+        }
+        prune();
+        clipboard.retain((id) => model.get(id));
+        recover(at);
+        ui.any = opened > 0;
+        persist();
+    }
+    function visible(list, out = []) {
+        let edit = peek(draft);
+        if (edit && !edit.element && list === (edit.parent ? edit.parent.children : top)) {
+            out.push(edit.row);
+        }
+        if (roots && !list.length && list !== top) {
+            let root = top.find((row) => row.children === list);
+            if (root) {
+                out.push(blank(root));
+            }
+        }
+        for (let i = 0, n = list.length; i < n; i++) {
+            let row = list[i];
+            if (hidden.has(row.id)) {
+                continue;
+            }
+            out.push(row);
+            if (row.open && peek(row.open)) {
+                visible(branch(row), out);
+            }
+        }
+        return out;
+    }
+    return (() => {
+        let root_187wopb1a = template_187wopb1b(), element_187wopb1c = root_187wopb1a.firstChild, element_187wopb1d = element_187wopb1c.firstElementChild, element_187wopb1e = element_187wopb1d.firstChild, element_187wopb1f = element_187wopb1e.nextSibling, element_187wopb1g = element_187wopb1d.nextElementSibling, element_187wopb1h = element_187wopb1g.firstElementChild, element_187wopb1i = element_187wopb1c.firstChild.nextSibling.nextSibling, element_187wopb1j = element_187wopb1i.nextSibling, element_187wopb1k = element_187wopb1j.nextSibling, element_187wopb1l = element_187wopb1k.nextSibling;
+        template_u1.slot(element_187wopb1e, highlight({ class: 'file-tree-highlight', target: '.file-tree-row' }));
+        template_u1.slot(element_187wopb1f, pins.render());
+        template_u1.slot(element_187wopb1d, slot.fragment, 2);
+        element_187wopb1h.appendChild(new template_u1.ArraySlot(ghosts, ghost, true).fragment);
+        new template_u1.EffectSlot(element_187wopb1i, () => empty && !rows.$length && !search?.filtering() && (() => {
+            let root_187wopb1m = template_187wopb1n(), element_187wopb1o = root_187wopb1m.firstChild;
+            template_u1.slot(element_187wopb1o, empty(), 1);
+            return root_187wopb1m;
+        })());
+        template_u1.slot(element_187wopb1j, search?.render(id));
+        template_u1.slot(element_187wopb1k, hint && tip.render({ 'aria-hidden': 'true', class: 'file-tree-tooltip' }));
+        template_u1.slot(element_187wopb1l, toggle && (() => {
+            let root_187wopb1p = template_187wopb1q(), element_187wopb1r = root_187wopb1p.firstChild;
+            new template_u1.EffectSlot(element_187wopb1r, () => ui.any ? 'Collapse all' : 'Expand all', 1);
+            template_u1.delegate(element_187wopb1r, 'click', () => all(!ui.any));
+            return root_187wopb1p;
+        })());
+        template_u1.slot(element_187wopb1c, dragging?.ghost, 2);
+        template_u1.setList(element_187wopb1h, 'style', () => `top: ${stage.edge}px;`);
+        template_u1.setList(element_187wopb1h, 'class', () => ui.motion && `file-tree-motion-layer--${ui.motion}`);
+        template_u1.setList(element_187wopb1g, 'style', () => `height: ${stage.height}px; left: ${stage.left}px; top: ${stage.top}px; width: ${stage.width}px;`);
+        template_u1.setList(element_187wopb1g, 'class', () => ui.motion && '--active');
+        template_u1.setProperty(element_187wopb1d, 'aria-label', label);
+        template_u1.setProperty(element_187wopb1d, 'id', id);
+        template_u1.setProperties(element_187wopb1d, dragging?.viewport);
+        template_u1.setProperty(element_187wopb1d, 'aria-activedescendant', () => read(focused) > 0 && `${id}-${read(focused)}`);
+        template_u1.onconnect(element_187wopb1d, (element) => {
+            viewport = element;
+        });
+        template_u1.delegate(element_187wopb1d, 'contextmenu', (event) => {
+            if (!menu || !viewport) {
+                return;
+            }
+            event.preventDefault();
+            let item = event.target.closest('.file-tree-row'), keyboard = !item && event.button !== 2, row = keyboard ? cursor : owner(item);
+            if (!row) {
+                menu([], { x: event.clientX, y: event.clientY }, false);
+                return;
+            }
+            let subject = keyboard ? segment(row) : pick(row, event);
+            if (!subject.locked && !selection.has(subject.id)) {
+                anchor = row;
+                selection.replace([subject.id]);
+                primary(subject.id);
+            }
+            focus(row);
+            let box = keyboard ? (node(row) ?? viewport).getBoundingClientRect() : null;
+            menu(targets(row, false), box ? { x: box.left, y: box.bottom } : { x: event.clientX, y: event.clientY }, header(row));
+        });
+        template_u1.delegate(element_187wopb1d, 'keydown', (event) => {
+            if (search?.key(event)) {
+                event.preventDefault();
+                return;
+            }
+            let index = cursor ? rows.indexOf(cursor) : -1, row = rows[index];
+            if (!row || !viewport) {
+                return;
+            }
+            let name = command(event);
+            if (name && perform(name, row)) {
+                event.preventDefault();
+                return;
+            }
+            let align = 'end', target = -1;
+            switch (event.key) {
+                case '*': {
+                    let siblings = row.parent ? branch(row.parent) : top;
+                    for (let i = 0, n = siblings.length; i < n; i++) {
+                        if (!siblings[i].locked) {
+                            expand(siblings[i], true);
+                        }
+                    }
+                    break;
+                }
+                case 'ArrowDown':
+                    target = index + 1;
+                    break;
+                case 'ArrowUp':
+                    align = 'start';
+                    target = index - 1;
+                    break;
+                case 'End':
+                    target = rows.$length - 1;
+                    break;
+                case 'Enter':
+                case ' ':
+                    activate(row, event.key === ' ' ? PREVIEW : { mode: 'pinned', side: event.ctrlKey || event.metaKey });
+                    break;
+                case 'F5':
+                    if (!event.altKey || event.ctrlKey || event.metaKey) {
+                        return;
+                    }
+                    void jump('change', event.shiftKey ? -1 : 1);
+                    break;
+                case 'F8':
+                    if (event.altKey || event.ctrlKey || event.metaKey) {
+                        return;
+                    }
+                    void jump('problem', event.shiftKey ? -1 : 1);
+                    break;
+                case 'F2':
+                    begin('rename');
+                    break;
+                case 'Home':
+                    align = 'start';
+                    target = 0;
+                    break;
+                case 'PageDown':
+                    target = Math.min(rows.$length - 1, index + page());
+                    break;
+                case 'PageUp':
+                    align = 'start';
+                    target = Math.max(0, index - page());
+                    break;
+                case 'ArrowLeft':
+                case 'ArrowRight': {
+                    let inward = (event.key === 'ArrowRight') !== (getComputedStyle(viewport).direction === 'rtl'), open = row.open && peek(row.open);
+                    if (event.altKey && row.open && (inward || open)) {
+                        all(inward, row);
+                    }
+                    else if (inward && row.open && !row.locked) {
+                        if (!open) {
+                            fold(row, true);
+                        }
+                        else if (row.element.children?.length) {
+                            target = index + 1;
+                        }
+                    }
+                    else if (!inward && open) {
+                        fold(row, false);
+                    }
+                    else if (!inward && row.parent) {
+                        align = 'start';
+                        target = rows.indexOf(row.parent);
+                    }
+                    break;
+                }
+                default:
+                    if (shortcuts && event.altKey && event.code === 'KeyN' && !event.ctrlKey && !event.metaKey) {
+                        begin(event.shiftKey ? 'folder' : 'file');
+                        break;
+                    }
+                    if (event.key.length !== 1 || event.altKey || event.ctrlKey || event.metaKey) {
+                        return;
+                    }
+                    if (search && typing === 'find') {
+                        search.type(event.key);
+                    }
+                    else {
+                        target = typeahead(event.key, index);
+                    }
+            }
+            event.preventDefault();
+            if (target !== -1) {
+                if (rows[target] && extending(event)) {
+                    span(row, rows[target]);
+                }
+                move(target, align);
+                if (cursor && cursor !== row) {
+                    follow(cursor);
+                }
+            }
+        });
+        template_u1.delegate(element_187wopb1d, 'mousedown', middle);
+        template_u1.on(element_187wopb1d, 'scroll', () => {
+            settle();
+            pins.update();
+            if (snapshot) {
+                snapshot.scroll = viewport.scrollTop;
+            }
+        });
+        template_u1.setProperties(element_187wopb1d, hint && {
+            onpointerleave: (event) => {
+                if (event.pointerType !== 'touch') {
+                    tip.release();
+                }
+            },
+            onpointerover: (event) => {
+                let scroller = event.currentTarget, target = event.target.closest('.file-tree-row'), row = owner(target);
+                if (!target || !row) {
+                    return;
+                }
+                if (!informative(row, target)) {
+                    tip.release();
+                    return;
+                }
+                tip.request(target, about(row), () => {
+                    let box = scroller.getBoundingClientRect(), rect = target.getBoundingClientRect();
+                    return new DOMRect(box.left, rect.top, box.width, rect.height);
+                });
+            }
+        });
+        template_u1.setList(element_187wopb1c, 'class', indicator !== 'never' && 'file-tree--indicator');
+        template_u1.setList(element_187wopb1c, 'class', indicator === 'hover' && 'file-tree--indicator-hover');
+        template_u1.setProperties(element_187wopb1c, attributes);
+        template_u1.setProperties(element_187wopb1c, dragging?.root);
+        template_u1.setList(element_187wopb1c, 'class', () => ui.motion && `file-tree--motion file-tree--motion-${ui.motion}`);
+        template_u1.delegate(element_187wopb1c, 'animationend', (event) => {
+            if (event.target === root) {
+                settle();
+            }
+        });
+        template_u1.onconnect(element_187wopb1c, (element) => {
+            root = element;
+            forget = history?.subscribe(retrace);
+            unwatch = model.subscribe(restructure);
+            if (seen !== model.version) {
+                resync();
+            }
+            effect(() => state.selected, (value) => {
+                write(current, value);
+                if (value === known) {
+                    return;
+                }
+                known = value;
+                if (!selection.has(value)) {
+                    anchor = built.get(value) ?? null;
+                    selection.replace(value ? [value] : []);
+                }
+                if (value !== quiet && autoreveal !== 'off') {
+                    reveal(value, autoreveal === 'on');
+                }
+                quiet = null;
+            });
+            effect(() => state.selection, (value) => {
+                if (!value || value === selection.ids) {
+                    return;
+                }
+                selection.replace(value);
+                if (!value.has(state.selected)) {
+                    primary(value.values().next().value ?? '');
+                }
+            });
+            effect(modes, (value) => {
+                if (value !== settings) {
+                    settings = value;
+                    filtered = filter(model.elements, display.dotfiles !== false, excluded, roots);
+                    redisplay();
+                    search?.refresh();
+                }
+            });
+            if (typeof phrase === 'function') {
+                effect(phrase, (value) => {
+                    write(given, value);
+                });
+            }
+            search?.refresh();
+            if (snapshot?.scroll) {
+                let offset = snapshot.scroll;
+                requestAnimationFrame(() => {
+                    viewport.scrollTop = offset;
+                });
+            }
+            detach = editor?.subscribe((request) => {
+                if (request.action === 'cancel') {
+                    close(!!viewport?.contains(document.activeElement));
+                }
+                else {
+                    begin(request.action, request.target);
+                }
+            });
+            if (!decorations) {
+                return;
+            }
+            unsubscribe = decorations.subscribe((ids) => {
+                decorate(ids);
+                search?.refresh();
+            });
+            decorate(new Set([...own.keys(), ...decorations.keys()]));
+        });
+        template_u1.ondisconnect(element_187wopb1c, () => {
+            clearTimeout(timer);
+            search?.dispose();
+            detach?.();
+            detach = undefined;
+            forget?.();
+            forget = undefined;
+            unsubscribe?.();
+            unsubscribe = undefined;
+            unwatch?.();
+            unwatch = undefined;
+        });
+        template_u1.setList(element_187wopb1c, 'style', () => ui.motion && `--motion-rows: ${ui.motionRows}`);
+        return root_187wopb1a;
+    })();
+};
+export { Decorations as FileTreeDecorations, Editor as FileTreeEditor, Elements as FileTreeElements, History as FileTreeHistory };
+export { createFileTreeIconResolver, glyph as fileTreeIcon, resolveFileTreeIcon };