@rightkit/document-workspace 0.0.0-stage → 0.1.0

package/dist/documents/txt/useSourceSearch.js

@@ -0,0 +1,122 @@
+import { useCallback, useRef } from "react";
+import { findLiteralMatches } from "@rightkit/document-core/documents/searchUtils";
+import { setSearchHighlights } from "./sourceExtensions.js";
+import { scrollPosIntoView } from "@rightkit/document-core/documents/txt/cmScroll";
+export function useSourceSearch({ viewRef, readOnlyRef, }) {
+    const searchRef = useRef({
+        query: "",
+        options: { matchCase: false, wholeWord: false },
+        matches: [],
+        activeIndex: -1,
+    });
+    const searchedDocumentRef = useRef(null);
+    const dispatchSearchHighlights = useCallback((matches, activeIndex) => {
+        const view = viewRef.current;
+        if (!view)
+            return;
+        const active = activeIndex >= 0 ? matches[activeIndex] : null;
+        const selection = active
+            ? { anchor: active.start, head: active.end }
+            : view.state.selection.main.empty
+                ? undefined
+                : { anchor: view.state.selection.main.head };
+        view.dispatch({
+            effects: setSearchHighlights.of({ matches, activeIndex }),
+            selection,
+        });
+        if (active)
+            scrollPosIntoView(view, active.start);
+    }, [viewRef]);
+    const clearSearch = useCallback(() => {
+        searchedDocumentRef.current = null;
+        searchRef.current = {
+            query: "",
+            options: searchRef.current.options,
+            matches: [],
+            activeIndex: -1,
+        };
+        dispatchSearchHighlights([], -1);
+    }, [dispatchSearchHighlights]);
+    const runFind = useCallback((query, options) => {
+        const view = viewRef.current;
+        if (!view || !query) {
+            searchedDocumentRef.current = null;
+            searchRef.current = { query, options, matches: [], activeIndex: -1 };
+            dispatchSearchHighlights([], -1);
+            return { count: 0, activeIndex: -1 };
+        }
+        const source = view.state.doc.toString();
+        const matches = findLiteralMatches(source, query, options);
+        const activeIndex = matches.length ? 0 : -1;
+        searchedDocumentRef.current = view.state.doc;
+        searchRef.current = { query, options, matches, activeIndex };
+        dispatchSearchHighlights(matches, activeIndex);
+        return { count: matches.length, activeIndex };
+    }, [dispatchSearchHighlights, viewRef]);
+    const refreshSearch = useCallback(() => {
+        const view = viewRef.current;
+        const cur = searchRef.current;
+        if (!view || !cur.query)
+            return { count: 0, activeIndex: -1 };
+        const matches = findLiteralMatches(view.state.doc.toString(), cur.query, cur.options);
+        const selection = view.state.selection.main;
+        const selectedIndex = matches.findIndex((match) => match.start === selection.from && match.end === selection.to);
+        const activeIndex = matches.length
+            ? selectedIndex >= 0
+                ? selectedIndex
+                : Math.min(Math.max(cur.activeIndex, 0), matches.length - 1)
+            : -1;
+        searchedDocumentRef.current = view.state.doc;
+        searchRef.current = { ...cur, matches, activeIndex };
+        dispatchSearchHighlights(matches, activeIndex);
+        return { count: matches.length, activeIndex };
+    }, [dispatchSearchHighlights, viewRef]);
+    const stepSearch = useCallback((delta) => {
+        if (viewRef.current?.state.doc !== searchedDocumentRef.current)
+            refreshSearch();
+        const cur = searchRef.current;
+        const count = cur.matches.length;
+        if (!count)
+            return { count: 0, activeIndex: -1 };
+        const activeIndex = (cur.activeIndex + delta + count) % count;
+        searchRef.current = { ...cur, activeIndex };
+        dispatchSearchHighlights(cur.matches, activeIndex);
+        return { count, activeIndex };
+    }, [dispatchSearchHighlights, refreshSearch, viewRef]);
+    const replaceAndFind = useCallback((replacement, all) => {
+        const view = viewRef.current;
+        const cur = searchRef.current;
+        if (!view || readOnlyRef.current)
+            return { count: cur.matches.length, activeIndex: cur.activeIndex };
+        // CodeMirror maps its selection/decorations on edits; cached match offsets do not move.
+        // Recompute from the live document before selecting or replacing a cached range.
+        if (view.state.doc !== searchedDocumentRef.current)
+            refreshSearch();
+        const current = searchRef.current;
+        const matches = all
+            ? current.matches
+            : current.matches[current.activeIndex]
+                ? [current.matches[current.activeIndex]]
+                : [];
+        if (matches.length) {
+            view.dispatch({
+                changes: matches.map((match) => ({
+                    from: match.start,
+                    to: match.end,
+                    insert: replacement,
+                })),
+                userEvent: "input.replace",
+            });
+        }
+        return runFind(current.query, current.options);
+    }, [readOnlyRef, refreshSearch, runFind, viewRef]);
+    return {
+        clearSearch,
+        dispatchSearchHighlights,
+        replaceAndFind,
+        refreshSearch,
+        runFind,
+        searchRef,
+        stepSearch,
+    };
+}

package/dist/documents/txt/useTextEditorCommands.d.ts

@@ -0,0 +1,26 @@
+import { type Dispatch, type MutableRefObject, type SetStateAction } from "react";
+import { EditorView } from "@codemirror/view";
+import { type SourceLanguage } from "./sourceFormatting.js";
+import type { SourceLinkPrefix, SourceLinkState } from "./sourceEditorTypes.js";
+export declare function useTextEditorCommands({ formatOnSaveRef, language, onSaveRef, readOnlyRef, setLinkState, setSourceFolded, sourceFolded, viewRef, }: {
+    formatOnSaveRef: MutableRefObject<boolean>;
+    language: SourceLanguage;
+    onSaveRef: MutableRefObject<() => void>;
+    readOnlyRef: MutableRefObject<boolean>;
+    setLinkState: Dispatch<SetStateAction<SourceLinkState | null>>;
+    setSourceFolded: Dispatch<SetStateAction<boolean>>;
+    sourceFolded: boolean;
+    viewRef: MutableRefObject<EditorView | null>;
+}): {
+    formatFromEditor: () => void;
+    formatTablesFromEditor: () => void;
+    goToLine: (lineNumber: number) => void;
+    insertBlock: (block: string, caretOffset?: number) => void;
+    insertLinkFromDialog: (state: SourceLinkState | null, label: string, url: string) => void;
+    linePrefix: (prefix: string) => void;
+    openLink: (prefix: SourceLinkPrefix) => void;
+    saveFromEditor: () => void;
+    setHeading: (level: number) => void;
+    toggleFoldAll: () => void;
+    wrapInline: (before: string, after: string) => void;
+};

package/dist/documents/txt/useTextEditorCommands.js

@@ -0,0 +1,151 @@
+import { useCallback } from "react";
+import { foldAll, unfoldAll } from "@codemirror/language";
+import { EditorView } from "@codemirror/view";
+import { applyInlineWrap, buildMarkdownLink, formatSource, } from "./sourceFormatting.js";
+export function useTextEditorCommands({ formatOnSaveRef, language, onSaveRef, readOnlyRef, setLinkState, setSourceFolded, sourceFolded, viewRef, }) {
+    const edit = useCallback((fn) => {
+        const view = viewRef.current;
+        if (!view || readOnlyRef.current)
+            return;
+        const sel = view.state.selection.main;
+        const result = fn(view.state.doc.toString(), sel.from, sel.to);
+        view.focus();
+        view.dispatch({
+            changes: { from: 0, to: view.state.doc.length, insert: result.value },
+            selection: { anchor: result.start, head: result.end },
+            userEvent: "input",
+        });
+    }, [readOnlyRef, viewRef]);
+    const wrapInline = useCallback((before, after) => edit((value, start, end) => applyInlineWrap(value, start, end, before, after)), [edit]);
+    const openLink = useCallback((prefix) => {
+        const view = viewRef.current;
+        if (!view || readOnlyRef.current)
+            return;
+        const sel = view.state.selection.main;
+        setLinkState({
+            start: sel.from,
+            end: sel.to,
+            text: view.state.sliceDoc(sel.from, sel.to),
+            prefix,
+        });
+    }, [readOnlyRef, setLinkState, viewRef]);
+    const formatFromEditor = useCallback(() => {
+        const view = viewRef.current;
+        if (!view || readOnlyRef.current)
+            return;
+        const current = view.state.doc.toString();
+        const next = formatSource(language, current);
+        if (next === current)
+            return;
+        view.focus();
+        view.dispatch({
+            changes: { from: 0, to: view.state.doc.length, insert: next },
+            selection: { anchor: Math.min(view.state.selection.main.head, next.length) },
+            userEvent: "input.format",
+        });
+    }, [language, readOnlyRef, viewRef]);
+    const formatTablesFromEditor = useCallback(() => {
+        const view = viewRef.current;
+        if (!view || readOnlyRef.current || language !== "markdown")
+            return;
+        const current = view.state.doc.toString();
+        void import("@rightkit/markdown-editor/documents/markdown/markdownTools").then(({ formatMarkdownTables }) => {
+            const next = formatMarkdownTables(current);
+            if (next === current)
+                return;
+            const liveView = viewRef.current;
+            if (!liveView)
+                return;
+            liveView.focus();
+            liveView.dispatch({
+                changes: { from: 0, to: liveView.state.doc.length, insert: next },
+                selection: { anchor: Math.min(liveView.state.selection.main.head, next.length) },
+                userEvent: "input.format",
+            });
+        });
+    }, [language, readOnlyRef, viewRef]);
+    const saveFromEditor = useCallback(() => {
+        if (formatOnSaveRef.current && language !== "plain")
+            formatFromEditor();
+        onSaveRef.current();
+    }, [formatFromEditor, formatOnSaveRef, language, onSaveRef]);
+    const toggleFoldAll = useCallback(() => {
+        const view = viewRef.current;
+        if (!view)
+            return;
+        if (sourceFolded)
+            unfoldAll(view);
+        else
+            foldAll(view);
+        setSourceFolded((value) => !value);
+    }, [setSourceFolded, sourceFolded, viewRef]);
+    const goToLine = useCallback((lineNumber) => {
+        const view = viewRef.current;
+        if (!view)
+            return;
+        const line = view.state.doc.line(Math.max(1, Math.min(lineNumber, view.state.doc.lines)));
+        view.focus();
+        view.dispatch({
+            selection: { anchor: line.from },
+            effects: EditorView.scrollIntoView(line.from, { y: "center" }),
+        });
+    }, [viewRef]);
+    const insertLinkFromDialog = (state, label, url) => {
+        const view = viewRef.current;
+        if (!view || !state || readOnlyRef.current)
+            return;
+        const md = buildMarkdownLink(state.prefix, label, url);
+        view.focus();
+        view.dispatch({
+            changes: { from: state.start, to: state.end, insert: md },
+            selection: { anchor: state.start + md.length },
+            userEvent: "input",
+        });
+    };
+    const linePrefix = (prefix) => edit((value, start, end) => {
+        const lineStart = value.lastIndexOf("\n", start - 1) + 1;
+        return {
+            value: value.slice(0, lineStart) + prefix + value.slice(lineStart),
+            start: start + prefix.length,
+            end: end + prefix.length,
+        };
+    });
+    const setHeading = (level) => edit((value, start, end) => {
+        const lineStart = value.lastIndexOf("\n", start - 1) + 1;
+        const nextLine = value.indexOf("\n", start);
+        const lineEnd = nextLine === -1 ? value.length : nextLine;
+        const line = value.slice(lineStart, lineEnd);
+        const stripped = line.replace(/^#{1,6}\s+/, "");
+        const prefix = level === 0 ? "" : `${"#".repeat(level)} `;
+        const nextLineText = prefix + stripped;
+        const delta = nextLineText.length - line.length;
+        return {
+            value: value.slice(0, lineStart) + nextLineText + value.slice(lineEnd),
+            start: start + delta,
+            end: end + delta,
+        };
+    });
+    const insertBlock = (block, caretOffset = block.length) => edit((value, start) => {
+        const lineStart = value.lastIndexOf("\n", start - 1) + 1;
+        const prefix = start === lineStart ? "" : "\n";
+        const insert = prefix + block;
+        return {
+            value: value.slice(0, start) + insert + value.slice(start),
+            start: start + prefix.length + caretOffset,
+            end: start + prefix.length + caretOffset,
+        };
+    });
+    return {
+        formatFromEditor,
+        formatTablesFromEditor,
+        goToLine,
+        insertBlock,
+        insertLinkFromDialog,
+        linePrefix,
+        openLink,
+        saveFromEditor,
+        setHeading,
+        toggleFoldAll,
+        wrapInline,
+    };
+}

package/dist/documents/web/LivePreviewPane.d.ts

@@ -0,0 +1,11 @@
+import type { LoadedDocument } from "@rightkit/document-core/documents/types";
+interface Props {
+    doc: LoadedDocument;
+}
+/**
+ * Preview of an explicit URL (Open URL → http(s)://...). Local `.html` files are NOT
+ * handled here anymore — they're owned by the normal html document tab (HtmlDocument), which renders
+ * the interactive/code/safe modes. `web` tabs are session-only URL previews.
+ */
+export declare function LivePreviewPane({ doc }: Props): import("react").JSX.Element;
+export {};

package/dist/documents/web/LivePreviewPane.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { openDevtools } from "@rightkit/document-core/state/tauriBridge";
+import { isHostAppOrigin } from "@rightkit/document-core/documents/web/webUrl";
+import { PreviewMessage } from "@rightkit/document-core/documents/PreviewMessage";
+import { viewportWidthPx } from "@rightkit/document-core/documents/previewViewport";
+import { PreviewChrome } from "@rightkit/document-core/documents/PreviewChrome";
+import { acquireResource } from "@rightkit/document-core/app/resourceCensus";
+import { hostAppName } from "../../appName.js";
+/**
+ * Preview of an explicit URL (Open URL → http(s)://...). Local `.html` files are NOT
+ * handled here anymore — they're owned by the normal html document tab (HtmlDocument), which renders
+ * the interactive/code/safe modes. `web` tabs are session-only URL previews.
+ */
+export function LivePreviewPane({ doc }) {
+    if (!doc.web) {
+        return (_jsx(PreviewMessage, { title: "Preview unavailable", body: "This tab is missing its web session metadata." }));
+    }
+    return _jsx(LiveUrlPreview, { web: doc.web, documentPath: doc.path });
+}
+function LiveUrlPreview({ web, documentPath }) {
+    const [reloadKey, setReloadKey] = useState(0);
+    const [viewport, setViewport] = useState("desktop");
+    const blockedOwnOrigin = isHostAppOrigin(web.url);
+    useEffect(() => {
+        if (blockedOwnOrigin)
+            return;
+        const release = acquireResource({
+            kind: "web-iframe",
+            documentPath,
+            format: "web",
+        });
+        return release;
+    }, [blockedOwnOrigin, documentPath]);
+    // Ctrl+R / F5 (dispatched from the global shortcut handler as "viewright:web-reload") remounts the
+    // iframe — same as the chrome reload button — so the URL re-fetches from its server.
+    useEffect(() => {
+        const onReload = () => setReloadKey((n) => n + 1);
+        window.addEventListener("viewright:web-reload", onReload);
+        return () => window.removeEventListener("viewright:web-reload", onReload);
+    }, []);
+    const width = viewportWidthPx(viewport); // null = full-width desktop; otherwise a device frame
+    // Security note (audited 2026-06-02): `allow-scripts allow-same-origin` is the documented
+    // sandbox-escape combo ONLY when the framed content is same-origin with this app — then it could
+    // reach window.frameElement and strip its own sandbox. Here `src` is a CROSS-ORIGIN web URL, so the
+    // framed page cannot access frameElement and cannot escape. `allow-same-origin` is required so the
+    // previewed page keeps its own cookies/storage/fetch + HMR. The self-origin block prevents the app
+    // from framing itself — do NOT remove allow-same-origin; no real security gain.
+    // `allow-popups` lets target=_blank links fire a new-window request, which Rust
+    // (context_menu::route_new_windows_to_tabs) intercepts for loopback URLs and reopens as a VR web
+    // tab; external target=_blank links still go to the OS browser by design.
+    const frame = (_jsx("iframe", { title: "Live URL preview", src: web.url, sandbox: "allow-scripts allow-same-origin allow-forms allow-popups", className: "h-full w-full border-0 bg-panel" }, reloadKey));
+    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col bg-ink", children: [_jsx(PreviewChrome, { address: web.url, viewport: viewport, onViewport: setViewport, onReload: () => setReloadKey((n) => n + 1), trailing: {
+                    label: "devtools",
+                    ariaLabel: "Open DevTools",
+                    onClick: () => void openDevtools(),
+                } }), blockedOwnOrigin ? (_jsx(PreviewMessage, { title: `${hostAppName()} cannot frame itself`, body: "Open a different localhost app or port." })) : width ? (_jsx("div", { className: "flex min-h-0 flex-1 justify-center overflow-auto bg-ink/50 p-4", children: _jsx("div", { className: "h-full overflow-hidden rounded-md border border-line bg-panel shadow-2xl", style: { width, maxWidth: "100%" }, children: frame }) })) : (_jsx("div", { className: "min-h-0 flex-1", children: frame }))] }));
+}

package/dist/env.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="vite/client" />
+
+declare module "*.css";
+declare module "*.svg" {
+  const src: string;
+  export default src;
+}
+declare module "*.png" {
+  const src: string;
+  export default src;
+}
+declare module "*.txt?raw" {
+  const text: string;
+  export default text;
+}
+declare module "*.tsv?raw" {
+  const text: string;
+  export default text;
+}
+declare module "*?url" {
+  const src: string;
+  export default src;
+}
+
+// Build-time switches a host may define (Vite `define`); every read is typeof-guarded.
+declare const __RIGHTKIT_QA__: boolean | undefined;
+declare const __RIGHTKIT_DEMO__: boolean | undefined;
+declare const __RIGHTKIT_MOCK__: boolean | undefined;
+declare const __APP_VERSION__: string | undefined;
+
+interface Window {
+  /** UI QA only: the data source a QA shell selects. */
+  __RIGHTKIT_QA_DATA_SOURCE__?: "engine";
+}
+
+declare module "@rightkit-host/legal/legal-manifest.json" {
+  const manifest: {
+    documents: Array<{ id: string; role: string; title: string; publicUrl: string; version?: string; sha256?: string; [key: string]: unknown }>;
+    [key: string]: unknown;
+  };
+  export default manifest;
+}
+declare module "@rightkit-host/legal/legal-manifest.json?raw" {
+  const text: string;
+  export default text;
+}
+declare module "@rightkit-host/src/generated/legal-contract.json" {
+  const contract: { acceptanceVersion: string; materialSha256: string; [key: string]: unknown };
+  export default contract;
+}
+declare module "@rightkit-host/package.json" {
+  export const version: string;
+  const pkg: { name: string; version: string };
+  export default pkg;
+}
+declare module "@rightkit-host/legal/*.md?raw" {
+  const text: string;
+  export default text;
+}
+
+declare module "virtual:rightkit-legal" {
+  export const LEGAL_DOCUMENTS: readonly { title: string; content: string }[];
+  export const LEGAL_VERSION: string;
+  export const LEGAL_DOCUMENTS_HASH: string;
+  export const LEGAL_RECEIPT_DOCUMENTS: readonly { id: string; role: string; version: string; sha256: string; treatment: string; material: boolean }[];
+}

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+export * from "./app/App.js";
+export * from "./app/AppDialogs.js";
+export * from "./app/AppDialogsHost.js";
+export * from "./app/AppLifecycle.js";
+export * from "./app/AppProvider.js";
+export * from "./app/AppRoot.js";
+export * from "./app/AppShell.js";
+export * from "./app/CommandPalette.js";
+export * from "./app/DocActionBar.js";
+export * from "./app/DocumentContextMenu.js";
+export * from "./app/DocumentPane.js";
+export * from "./app/DocumentRouterTable.js";
+export * from "./app/ErrorBoundary.js";
+export * from "./app/FindBar.js";
+export * from "./app/LiveTitle.js";
+export * from "./app/OpeningProgress.js";
+export * from "./app/PrintPreviewWindow.js";
+export * from "./app/ShortcutHelp.js";
+export * from "./app/Sidebar.js";
+export * from "./app/ToastViewport.js";
+export * from "./app/Toolbar.js";
+export * from "./app/activeFormatSavers.js";
+export * from "./app/clipboardPaths.js";
+export * from "./app/documentDrafts.js";
+export * from "./app/draftResolution.js";
+export * from "./app/markdownPaletteActions.js";
+export * from "./app/resourceCensusDev.js";
+export * from "./app/setupRecovery.js";
+export * from "./app/shell/DocStatsPill.js";
+export * from "./app/shell/DocumentTools.js";
+export * from "./app/shell/InfoInspector.js";
+export * from "./app/shell/StartPage.js";
+export * from "./app/shell/readEdit.js";
+export * from "./app/sidebar/SidebarDocumentMenu.js";
+export * from "./app/sidebar/SidebarExpandedPanel.js";
+export * from "./app/sidebar/SidebarIcons.js";
+export * from "./app/sidebar/SidebarMenus.js";
+export * from "./app/sidebar/SidebarPathUtils.js";
+export * from "./app/sidebar/SidebarPrimitives.js";
+export * from "./app/sidebar/SidebarRail.js";
+export * from "./app/sidebar/explorer/ExplorerRowMenu.js";
+export * from "./app/sidebar/explorer/ExplorerSections.js";
+export * from "./app/sidebar/explorer/ExplorerTree.js";
+export * from "./app/sidebar/explorer/explorerState.js";
+export * from "./app/tabMountPolicy.js";
+export * from "./app/tabWarmOrder.js";
+export * from "./app/tabs/TabFuseCurves.js";
+export * from "./app/tabs/TabOverview.js";
+export * from "./app/tabs/TabStrip.js";
+export * from "./app/tabs/tabIds.js";
+export * from "./app/tabs/useTabDirty.js";
+export * from "./app/useAppChromeState.js";
+export * from "./app/useAppCommands.js";
+export * from "./app/useAppDocumentCore.js";
+export * from "./app/useAppEffects.js";
+export * from "./app/useAppPaneSearch.js";
+export * from "./app/useAppShellSetup.js";
+export * from "./app/useAppSlots.js";
+export * from "./app/useAppTabChrome.js";
+export * from "./app/useAutoSave.js";
+export * from "./app/useCloseAll.js";
+export * from "./app/useClosedTabEviction.js";
+export * from "./app/useCommandPalette.js";
+export * from "./app/useCrossDocSearch.js";
+export * from "./app/useDistractionFree.js";
+export * from "./app/useDocumentCreation.js";
+export * from "./app/useDocumentDirty.js";
+export * from "./app/useDocumentLoader.js";
+export * from "./app/useDocumentOutputActions.js";
+export * from "./app/useDocumentRuntimeEffects.js";
+export * from "./app/useDocumentSaver.js";
+export * from "./app/useDocumentTabs.js";
+export * from "./app/useDocumentWatcher.js";
+export * from "./app/useDocumentZoom.js";
+export * from "./app/useDraftConfirmGate.js";
+export * from "./app/useFileDragOverlay.js";
+export * from "./app/useFormatApis.js";
+export * from "./app/useFormatDirtyState.js";
+export * from "./app/useGlobalShortcuts.js";
+export * from "./app/useHtmlSession.js";
+export * from "./app/useHtmlSessionProps.js";
+export * from "./app/useLibrary.js";
+export * from "./app/useOpenFromClipboard.js";
+export * from "./app/usePaneLiveness.js";
+export * from "./app/usePendingSavePaths.js";
+export * from "./app/useReadyShow.js";
+export * from "./app/useSearchController.js";
+export * from "./app/useSetupRecovery.js";
+export * from "./app/useTabChrome.js";
+export * from "./app/useViewState.js";
+export * from "./appName.js";
+export * from "./documents/DocumentRouter.js";
+export * from "./documents/FileTypeIcon.js";
+export * from "./documents/ImageDocument.js";
+export * from "./documents/capabilities.js";
+export * from "./documents/html/HtmlDocument.js";
+export * from "./documents/html/HtmlDocumentLayout.js";
+export * from "./documents/html/HtmlDocumentSource.js";
+export * from "./documents/markdown/MarkdownSplitPane.js";
+export * from "./documents/mdx/MdxSplitPane.js";
+export * from "./documents/txt/LinkDialog.js";
+export * from "./documents/txt/MarkdownSourceToolbar.js";
+export * from "./documents/txt/SourceEditorToolbar.js";
+export * from "./documents/txt/TxtEditor.js";
+export * from "./documents/txt/sourceExtensions.js";
+export * from "./documents/txt/sourceTheme.js";
+export * from "./documents/txt/useCodeMirrorSourceEditor.js";
+export * from "./documents/txt/useSourceSearch.js";
+export * from "./documents/txt/useTextEditorCommands.js";
+export * from "./documents/web/LivePreviewPane.js";
+export * from "./settings/AppearanceMenu.js";
+export * from "./settings/SettingsPanel.js";
+export * from "./settings/publishedSections.js";
+export * from "./settings/sections/AboutSection.js";
+export * from "./settings/sections/DiagnosticsSection.js";
+export * from "./settings/sections/PrivacySection.js";
+export * from "./settings/sections/UpdateLicenseBlock.js";
+export * from "./state/explorer.js";
+export * from "./state/legal.js";
+export * from "./state/library.js";
+export * from "./state/updateLicense.js";