@esportsplus/ui 0.57.0 → 0.58.0

package/build/components/editor/workspace/session.js

@@ -0,0 +1,373 @@
+import { effect, read, root, signal, untrack, write } from '@esportsplus/reactivity';
+import Decorations from '../tree/decorations.js';
+import { containsPath, dirty, workspacePath } from './model.js';
+const DELAY = 500;
+function code(controller) {
+    return 'folds' in controller && 'nextChange' in controller;
+}
+function message(error) {
+    return (error instanceof Error ? error.message : String(error)).replace(/^Workspace: /, '');
+}
+function numbers(value) {
+    return Array.isArray(value) ? value.filter((item) => Number.isFinite(item)) : [];
+}
+function offset(value, length) {
+    return Number.isFinite(value) ? Math.max(0, Math.min(length, Math.trunc(value))) : 0;
+}
+function parse(value) {
+    if (!value || typeof value !== 'object' || !Array.isArray(value.tabs)) {
+        return null;
+    }
+    let tabs = [];
+    for (let i = 0, n = value.tabs.length; i < n; i++) {
+        let tab = value.tabs[i];
+        if (!tab || typeof tab.path !== 'string') {
+            continue;
+        }
+        tabs.push({
+            ...(typeof tab.draft === 'string' ? { draft: tab.draft } : {}),
+            folds: numbers(tab.folds),
+            path: tab.path,
+            pinned: tab.pinned === true,
+            preview: tab.preview === true,
+            scroll: { left: Math.max(0, Number(tab.scroll?.left) || 0), top: Math.max(0, Number(tab.scroll?.top) || 0) },
+            selection: { anchor: Number(tab.selection?.anchor) || 0, head: Number(tab.selection?.head) || 0 }
+        });
+    }
+    return {
+        active: typeof value.active === 'string' ? value.active : null,
+        explorer: {
+            expanded: Array.isArray(value.explorer?.expanded) ? value.explorer.expanded.filter((id) => typeof id === 'string') : [],
+            scroll: Math.max(0, Number(value.explorer?.scroll) || 0)
+        },
+        tabs
+    };
+}
+function selection(tab) {
+    let { direction, end, start } = tab.document.selection;
+    return direction === 'backward' ? { anchor: end, head: start } : { anchor: start, head: end };
+}
+const hosted = (model, current, delay = DELAY) => {
+    let baselines = new Map(), disposed = false, documents = new Map(), explorer = {}, folded = new WeakMap(), host = model.host, last = '', marks = new Decorations(), pending = new WeakMap(), problems = new Map(), ready = signal(!host.session), restored = !host.session, restoring, stopProblems, timer, waiters = new Map();
+    function capture() {
+        let shown = current(), state = model.state, tabs = [];
+        for (let i = 0, n = state.tabs.length; i < n; i++) {
+            let tab = state.tabs[i];
+            if (tab.compare) {
+                continue;
+            }
+            let live = shown?.tab === tab && shown.controller.host?.isConnected ? shown.controller : undefined, item = {
+                folds: live && code(live) ? live.folds() : (folded.get(tab) ?? pending.get(tab) ?? []),
+                path: tab.path,
+                pinned: tab.pinned,
+                preview: tab.preview,
+                scroll: live ? { left: live.scroller.scrollLeft, top: live.scroller.scrollTop } : { ...tab.scroll },
+                selection: selection(tab)
+            };
+            if (dirty(tab) || tab.missing) {
+                item.draft = tab.document.value;
+            }
+            tabs.push(item);
+        }
+        return {
+            active: state.active && !state.active.compare ? state.active.path : null,
+            explorer: { expanded: [...(explorer.expanded ?? [])], scroll: explorer.scroll ?? 0 },
+            tabs
+        };
+    }
+    async function fetch(path, entry) {
+        let cwd = model.state.cwd, request = ++entry.request, text = null;
+        try {
+            text = await host.baseline(cwd, path);
+        }
+        catch (error) {
+            if (baselines.get(path) === entry) {
+                model.status(`Could not read the baseline of ${path}: ${message(error)}`, true);
+            }
+        }
+        if (!disposed && baselines.get(path) === entry && entry.request === request && cwd === model.state.cwd) {
+            write(entry.text, typeof text === 'string' ? text : null);
+            mark();
+        }
+    }
+    function flush() {
+        clearTimeout(timer);
+        timer = undefined;
+        mark();
+        if (!restored || !host.session) {
+            return;
+        }
+        let session = capture(), json = JSON.stringify(session);
+        if (json === last) {
+            return;
+        }
+        last = json;
+        host.session.set(session).catch((error) => {
+            last = '';
+            model.status(`Could not save the session: ${message(error)}`, true);
+        });
+    }
+    function mark() {
+        let entries = [], tabs = model.state.tabs;
+        for (let i = 0, n = tabs.length; i < n; i++) {
+            let tab = tabs[i], baseline = baselines.get(tab.path), counts = problems.get(tab), decoration = {}, text = baseline && untrack(() => read(baseline.text));
+            if (typeof text === 'string' && text !== tab.document.value) {
+                decoration.status = 'modified';
+            }
+            if (counts?.errors) {
+                decoration.errors = counts.errors;
+            }
+            if (counts?.warnings) {
+                decoration.warnings = counts.warnings;
+            }
+            if (decoration.errors || decoration.status || decoration.warnings) {
+                entries.push([tab.path, decoration]);
+            }
+        }
+        marks.replace(entries);
+    }
+    async function reopen(session) {
+        let cwd = model.state.cwd;
+        for (let i = 0, n = session.tabs.length; i < n; i++) {
+            let item = session.tabs[i], content, path;
+            try {
+                path = workspacePath(item.path, cwd);
+            }
+            catch {
+                continue;
+            }
+            try {
+                content = await host.read(cwd, path);
+            }
+            catch {
+                content = undefined;
+            }
+            if (disposed || cwd !== model.state.cwd) {
+                return;
+            }
+            if (content === undefined && item.draft === undefined) {
+                continue;
+            }
+            let tab = model.adopt(path, item.draft ?? content, content ?? '', content === undefined);
+            if (!tab) {
+                continue;
+            }
+            let length = tab.document.value.length, anchor = offset(item.selection.anchor, length), head = offset(item.selection.head, length);
+            if (item.pinned) {
+                model.pin(path);
+            }
+            else {
+                tab.preview = item.preview;
+            }
+            tab.scroll = { ...item.scroll };
+            tab.document.select({ direction: head < anchor ? 'backward' : 'forward', end: Math.max(anchor, head), start: Math.min(anchor, head) });
+            if (item.folds.length) {
+                pending.set(tab, item.folds);
+            }
+        }
+        if (session.active && !model.state.active && !model.state.opening.length) {
+            model.activate(session.active);
+        }
+    }
+    function schedule() {
+        clearTimeout(timer);
+        timer = setTimeout(flush, delay);
+    }
+    function settle(tab, controller) {
+        let list = waiters.get(tab);
+        waiters.delete(tab);
+        for (let i = 0, n = list?.length ?? 0; i < n; i++) {
+            list[i](controller);
+        }
+    }
+    function sync() {
+        let open = new Set(), tabs = model.state.tabs;
+        for (let i = 0, n = tabs.length; i < n; i++) {
+            let tab = tabs[i];
+            open.add(tab.path);
+            if (!documents.has(tab)) {
+                documents.set(tab, tab.document.subscribe((_, change) => {
+                    if (change.selectionChanged || change.textChanged) {
+                        schedule();
+                    }
+                }));
+            }
+            if (!host.baseline) {
+                continue;
+            }
+            let entry = baselines.get(tab.path);
+            if (!entry) {
+                track(tab);
+            }
+            else if (entry.saved !== tab.saved) {
+                entry.saved = tab.saved;
+                entry.fetched = fetch(tab.path, entry);
+            }
+        }
+        for (let [tab, stop] of documents) {
+            if (!tabs.includes(tab)) {
+                stop();
+                documents.delete(tab);
+                problems.delete(tab);
+                settle(tab, undefined);
+            }
+        }
+        for (let path of [...baselines.keys()]) {
+            if (!open.has(path)) {
+                baselines.delete(path);
+            }
+        }
+        schedule();
+    }
+    function track(tab) {
+        let entry = { fetched: Promise.resolve(), request: 0, saved: tab.saved, text: signal(null) };
+        baselines.set(tab.path, entry);
+        entry.fetched = fetch(tab.path, entry);
+        return entry;
+    }
+    function watched(event) {
+        for (let [path, entry] of baselines) {
+            if (!event.paths || event.paths.some((changed) => containsPath(changed, path))) {
+                entry.fetched = fetch(path, entry);
+            }
+        }
+    }
+    return {
+        baseline(path) {
+            if (!host.baseline) {
+                return undefined;
+            }
+            let entry = baselines.get(path) ?? untrack(() => {
+                let tab = model.state.tabs.find((item) => item.path === path);
+                return tab && track(tab);
+            });
+            return entry ? read(entry.text) : null;
+        },
+        connect(element) {
+            let listening = new AbortController(), unsubscribe = model.subscribe(sync), unwatch = model.onWatch(watched);
+            element.addEventListener('keyup', schedule, { capture: true, passive: true, signal: listening.signal });
+            element.addEventListener('pointerup', schedule, { capture: true, passive: true, signal: listening.signal });
+            element.addEventListener('scroll', schedule, { capture: true, passive: true, signal: listening.signal });
+            element.ownerDocument.defaultView?.addEventListener('pagehide', flush, { signal: listening.signal });
+            sync();
+            return () => {
+                listening.abort();
+                unsubscribe();
+                unwatch();
+                flush();
+                stopProblems?.();
+                stopProblems = undefined;
+                for (let stop of documents.values()) {
+                    stop();
+                }
+                documents.clear();
+            };
+        },
+        dispose() {
+            flush();
+            disposed = true;
+        },
+        explorer,
+        export: host.export && ((element) => host.export(model.state.cwd, element.id)),
+        flush,
+        import: host.import && (async (target, entries) => {
+            let folder = !target ? '' : target.type === 'file' ? target.id.slice(0, Math.max(0, target.id.lastIndexOf('/'))) : target.id;
+            try {
+                await host.import(model.state.cwd, folder, entries);
+            }
+            catch (error) {
+                model.status(`Import failed: ${message(error)}`, true);
+                return;
+            }
+            model.status(`Imported ${entries.length === 1 ? entries[0].path : `${entries.length} items`}`);
+            await model.refresh();
+        }),
+        async loaded(path) {
+            let entry = baselines.get(path);
+            while (entry && baselines.get(path) === entry) {
+                let fetched = entry.fetched;
+                await fetched;
+                if (fetched === entry.fetched) {
+                    break;
+                }
+            }
+            return entry && baselines.get(path) === entry ? untrack(() => read(entry.text)) : null;
+        },
+        mark,
+        marks,
+        ready: () => read(ready),
+        remember(tab, controller) {
+            if (code(controller)) {
+                folded.set(tab, controller.folds());
+            }
+        },
+        restore() {
+            if (!host.session || restored) {
+                return model.start();
+            }
+            return restoring ??= (async () => {
+                let loading = model.start(), session = null;
+                try {
+                    session = parse(await host.session.get());
+                }
+                catch (error) {
+                    model.status(`Could not restore the session: ${message(error)}`, true);
+                }
+                await loading;
+                if (disposed) {
+                    return;
+                }
+                if (session) {
+                    explorer.expanded = session.explorer.expanded;
+                    explorer.scroll = session.explorer.scroll;
+                    last = JSON.stringify(session);
+                }
+                write(ready, true);
+                try {
+                    if (session) {
+                        await reopen(session);
+                    }
+                }
+                finally {
+                    restored = true;
+                }
+            })();
+        },
+        shown(tab, controller) {
+            let lines = pending.get(tab);
+            pending.delete(tab);
+            if (code(controller)) {
+                for (let i = 0, n = lines?.length ?? 0; i < n; i++) {
+                    controller.fold(lines[i]);
+                }
+                stopProblems?.();
+                stopProblems = root((dispose) => {
+                    effect(() => {
+                        let { errors, warnings } = controller.state.problems;
+                        untrack(() => {
+                            if (current()?.tab === tab) {
+                                problems.set(tab, { errors, warnings });
+                                mark();
+                            }
+                        });
+                    });
+                    return dispose;
+                });
+            }
+            settle(tab, controller);
+        },
+        whenShown(tab) {
+            let shown = current();
+            if (shown?.tab === tab) {
+                return Promise.resolve(shown.controller);
+            }
+            return new Promise((resolve) => {
+                let list = waiters.get(tab) ?? [];
+                list.push(resolve);
+                waiters.set(tab, list);
+            });
+        }
+    };
+};
+export default hosted;
+export { parse };

package/build/components/editor/workspace/shortcuts.d.ts

@@ -0,0 +1,19 @@
+import * as template_u1 from '@esportsplus/template';
+import type { Command as PaletteCommand } from '../../command/index.js';
+import { type Keybindings } from './keybindings.js';
+import '../../button/scss/index.scss';
+import './scss/keybindings.scss';
+type A = {
+    apple: boolean;
+    id: string;
+    keybindings: () => Keybindings;
+    onchange: (keybindings: Keybindings) => void;
+    state: {
+        active: boolean;
+    };
+};
+declare const OPEN: readonly ['Mod+k', 'Mod+s'];
+declare const PALETTE: PaletteCommand;
+declare const shortcuts: ({ apple, id, keybindings, onchange, state }: A) => template_u1.Renderable<any>;
+export default shortcuts;
+export { OPEN, PALETTE };

package/build/components/editor/workspace/shortcuts.js

@@ -0,0 +1,185 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+import { computed, effect, read, signal, untrack, write } from '@esportsplus/reactivity';
+import * as template_u1 from '@esportsplus/template';
+import input from '../../input/index.js';
+import overlay from '../../overlay/index.js';
+import shortcutRecorder from '../../shortcut-recorder/index.js';
+import scrollbar from '../../../modifiers/scrollbar/index.js';
+import { bind, conflict, fromChord, fromRecorder, label, matches, reset, rows, unassign } from './keybindings.js';
+import keyboard from '@esportsplus/ui/svg/keyboard.svg';
+import '../../button/scss/index.scss';
+import './scss/keybindings.scss';
+const template_1xp781n3 = template_u1.template(`<div class='code-workspace-keybindings-row' role='row'><div class='code-workspace-keybindings-command' role='cell'><span class='code-workspace-keybindings-label'></span><span class='code-workspace-keybindings-id'></span></div><div class='code-workspace-keybindings-keys' role='cell'><!--$--><!--$--><!--$--></div><div class='code-workspace-keybindings-source' role='cell'></div><div class='code-workspace-keybindings-actions' role='cell'><button class='button code-workspace-keybindings-button' type='button'> Reset `);
+const template_1xp781ne = template_u1.template(`<kbd class='button button--kbd code-workspace-keybindings-key code-workspace-keybindings-key--builtin' title='Built into the editor and not removable here; a chord bound to another command takes it over'>`);
+const template_1xp781nh = template_u1.template(`<kbd class='button button--kbd code-workspace-keybindings-key'>`);
+const template_1xp781nk = template_u1.template(`<div class='code-workspace-keybindings-conflict' role='alert'><span class='code-workspace-keybindings-conflict-text'><!--$--> is bound to <!--$-->. </span><button class='button code-workspace-keybindings-button code-workspace-keybindings-button--primary' type='button'> Replace </button><button class='button code-workspace-keybindings-button' type='button'> Cancel `);
+const template_1xp781nq = template_u1.template(`<div class='code-workspace-keybindings-header'><h2 class='code-workspace-keybindings-title'>Keyboard Shortcuts</h2><button class='button code-workspace-keybindings-button' type='button'> Reset all </button></div><!--$--><div aria-label='Keybindings' class='code-workspace-keybindings-table' role='table'><div class='code-workspace-keybindings-row code-workspace-keybindings-row--head' role='row'><span role='columnheader'>Command</span><span role='columnheader'>Keybinding</span><span role='columnheader'>Source</span><span role='columnheader'><span class='code-workspace-keybindings-hidden'>Reset</span></span></div><!--$-->`);
+const template_1xp781nw = template_u1.template(`<div class='code-workspace-keybindings-empty' role='status'>No commands match`);
+class ReactiveObject_1xp781n0 extends reactivity_u0.ReactiveObject {
+    #query = this[reactivity_u0.SIGNAL]('');
+    constructor() {
+        super(null);
+    }
+    get query() {
+        return reactivity_u0.read(this.#query);
+    }
+    set query(_v0) {
+        reactivity_u0.write(this.#query, _v0);
+    }
+}
+class ReactiveObject_1xp781n1 extends reactivity_u0.ReactiveObject {
+    #error = this[reactivity_u0.SIGNAL]('');
+    #value;
+    constructor(_p0) {
+        super(null);
+        this.#value = this[reactivity_u0.SIGNAL](_p0);
+    }
+    get error() {
+        return reactivity_u0.read(this.#error);
+    }
+    set error(_v0) {
+        reactivity_u0.write(this.#error, _v0);
+    }
+    get value() {
+        return reactivity_u0.read(this.#value);
+    }
+    set value(_v1) {
+        reactivity_u0.write(this.#value, _v1);
+    }
+}
+const OPEN = ['Mod+k', 'Mod+s'];
+const PALETTE = {
+    group: 'Preferences',
+    icon: keyboard,
+    id: 'workspace.keybindings',
+    label: 'Open Keyboard Shortcuts'
+};
+const shortcuts = ({ apple, id, keybindings, onchange, state }) => {
+    let current = computed(() => rows(keybindings(), apple)), initial = untrack(() => read(current)), names = new Map(initial.map((row) => [row.id, row.label])), pending = signal(undefined), ui = new ReactiveObject_1xp781n0();
+    function apply(next) {
+        write(pending, undefined);
+        onchange(next);
+    }
+    function confirm() {
+        let held = read(pending);
+        if (held) {
+            onchange(bind(keybindings(), apple, held.command, held.keys));
+        }
+        write(pending, undefined);
+    }
+    function shown(row) {
+        return row.chords.length ? fromChord(row.chords[0], apple) : '';
+    }
+    function record(index, value) {
+        let row = read(current)[index];
+        if (value === shown(row)) {
+            return;
+        }
+        if (!value) {
+            apply(unassign(keybindings(), apple, row.id));
+            return;
+        }
+        let keys = fromRecorder(value, apple);
+        if (!keys) {
+            write(pending, undefined);
+            return;
+        }
+        let owner = conflict(keybindings(), apple, row.id, keys);
+        if (owner) {
+            write(pending, { command: row.id, keys, owner });
+            return;
+        }
+        apply(bind(keybindings(), apple, row.id, keys));
+    }
+    function row(info, index) {
+        let recorder = new ReactiveObject_1xp781n1(shown(info)), entry = () => read(current)[index], adding = () => !entry().chords.length && entry().builtin.length > 0;
+        effect(() => {
+            let held = read(pending)?.command === info.id, value = shown(entry());
+            if (!held) {
+                untrack(() => {
+                    recorder.value = value;
+                });
+            }
+        });
+        effect(() => {
+            let value = recorder.value;
+            untrack(() => record(index, value));
+        });
+        return (() => {
+            let root_1xp781n2 = template_1xp781n3(), element_1xp781n4 = root_1xp781n2.firstChild, element_1xp781n5 = element_1xp781n4.firstElementChild.firstElementChild, element_1xp781n6 = element_1xp781n5.nextElementSibling, element_1xp781n7 = element_1xp781n4.firstElementChild.nextElementSibling.firstChild, element_1xp781n8 = element_1xp781n7.nextSibling, element_1xp781n9 = element_1xp781n8.nextSibling, element_1xp781na = element_1xp781n4.firstElementChild.nextElementSibling, element_1xp781nb = element_1xp781na.nextElementSibling, element_1xp781nc = element_1xp781nb.nextElementSibling.firstElementChild;
+            template_u1.slot(element_1xp781n5, info.label, 1);
+            template_u1.slot(element_1xp781n6, info.id, 1);
+            new template_u1.EffectSlot(element_1xp781n7, () => entry().builtin.map((keys) => {
+                let root_1xp781nd = template_1xp781ne(), element_1xp781nf = root_1xp781nd.firstChild;
+                template_u1.slot(element_1xp781nf, label(keys, apple), 1);
+                return root_1xp781nd;
+            }));
+            template_u1.slot(element_1xp781n8, shortcutRecorder({
+                'aria-label': `Keybinding for ${info.label}`,
+                class: ['code-workspace-keybindings-recorder', () => adding() && 'code-workspace-keybindings-recorder--add'],
+                state: recorder,
+                taken: (shortcut) => (fromRecorder(shortcut, apple) === OPEN[0] ? 'the keyboard shortcuts chord' : null),
+                title: () => (adding() ? `Add a keybinding for ${info.label}` : undefined)
+            }));
+            new template_u1.EffectSlot(element_1xp781n9, () => entry().chords.slice(1).map((keys) => {
+                let root_1xp781ng = template_1xp781nh(), element_1xp781ni = root_1xp781ng.firstChild;
+                template_u1.slot(element_1xp781ni, label(keys, apple), 1);
+                return root_1xp781ng;
+            }));
+            new template_u1.EffectSlot(element_1xp781na, () => {
+                let held = read(pending);
+                if (held?.command !== info.id) {
+                    return '';
+                }
+                return (() => {
+                    let root_1xp781nj = template_1xp781nk(), element_1xp781nl = root_1xp781nj.firstChild.firstElementChild.firstChild, element_1xp781nm = element_1xp781nl.nextSibling.nextSibling, element_1xp781nn = root_1xp781nj.firstChild.firstElementChild.nextElementSibling, element_1xp781no = element_1xp781nn.nextElementSibling;
+                    template_u1.slot(element_1xp781nl, label(held.keys, apple));
+                    template_u1.slot(element_1xp781nm, names.get(held.owner));
+                    template_u1.delegate(element_1xp781no, 'click', () => write(pending, undefined));
+                    template_u1.delegate(element_1xp781nn, 'click', confirm);
+                    return root_1xp781nj;
+                })();
+            }, 2);
+            new template_u1.EffectSlot(element_1xp781nb, () => (entry().user ? 'User' : 'Default'), 1);
+            template_u1.setProperty(element_1xp781nc, 'aria-label', `Reset ${info.label}`);
+            template_u1.setProperty(element_1xp781nc, 'disabled', () => !entry().user);
+            template_u1.delegate(element_1xp781nc, 'click', () => apply(reset(keybindings(), apple, info.id)));
+            template_u1.setProperty(element_1xp781n4, 'hidden', () => !matches(entry(), ui.query, apple));
+            return root_1xp781n2;
+        })();
+    }
+    effect(() => {
+        if (!state.active) {
+            untrack(() => write(pending, undefined));
+        }
+    });
+    return overlay({
+        'aria-labelledby': `${id}-keybindings`,
+        class: 'card code-workspace-keybindings',
+        state
+    }, (() => {
+        let root_1xp781np = template_1xp781nq(), element_1xp781nr = root_1xp781np.firstChild.firstElementChild, element_1xp781ns = element_1xp781nr.nextElementSibling, element_1xp781nt = root_1xp781np.firstChild.nextSibling, element_1xp781nu = element_1xp781nt.nextSibling, element_1xp781nv = element_1xp781nu.firstChild.nextSibling;
+        template_u1.slot(element_1xp781nt, input({
+            'aria-label': 'Search keybindings',
+            autocomplete: 'off',
+            autofocus: true,
+            class: 'code-workspace-keybindings-search',
+            oninput: (event) => {
+                ui.query = event.target.value;
+            },
+            placeholder: 'Search by command, id or key',
+            spellcheck: false,
+            type: 'search',
+            value: () => ui.query
+        }));
+        template_u1.slot(element_1xp781nv, initial.map(row));
+        new template_u1.EffectSlot(element_1xp781nu, () => read(current).every((entry) => !matches(entry, ui.query, apple)) && template_1xp781nw(), 2);
+        template_u1.setProperties(element_1xp781nu, scrollbar());
+        template_u1.setProperty(element_1xp781ns, 'disabled', () => !Object.keys(keybindings()).length);
+        template_u1.delegate(element_1xp781ns, 'click', () => apply({}));
+        template_u1.setProperty(element_1xp781nr, 'id', template_u1.interpolate([(id), "-keybindings"]));
+        return root_1xp781np;
+    })());
+};
+export default shortcuts;
+export { OPEN, PALETTE };

package/build/components/editor/workspace/status.d.ts

@@ -0,0 +1,34 @@
+import type { EditorDocument, Language, Options } from '../code/index.js';
+import type { Status } from '../../inline-edit/status.js';
+import { type EditorWorkspaceModel, type WorkspacePreferences } from './model.js';
+type AutoSaveMode = WorkspacePreferences['autoSave'];
+type Indentation = {
+    size: number;
+    tabs: boolean;
+};
+type LineEnding = 'crlf' | 'lf';
+declare const AUTO_SAVE_MODES: Record<AutoSaveMode, string>;
+declare const INDENT_SIZES: number[];
+declare const LANGUAGES: Record<Language, string>;
+declare function indentation({ size, tabs }: Indentation): Options;
+declare function indentLabel({ size, tabs }: Indentation): string;
+declare function lineEndings(document: EditorDocument, eol: LineEnding): boolean;
+declare class AutoSave {
+    readonly model: EditorWorkspaceModel;
+    readonly status: Status;
+    private active;
+    private mode;
+    private pending;
+    private tabs;
+    private unsubscribe;
+    constructor(model: EditorWorkspaceModel);
+    private edited;
+    private phase;
+    private save;
+    private sync;
+    blur(all?: boolean): void;
+    connect(): () => void;
+    disconnect(): void;
+}
+export { AUTO_SAVE_MODES, AutoSave, INDENT_SIZES, indentation, indentLabel, LANGUAGES, lineEndings };
+export type { AutoSaveMode, Indentation, LineEnding };