@tulipfarm/sprout 0.0.0-stage → 0.1.0

package/dist/internal/message-scroller.js

@@ -0,0 +1,637 @@
+// The scroll engine behind MessageScroller: follows new output, pins a new
+// turn under the top edge, keeps the reader's place when older messages are
+// prepended, and reports which edges can still be scrolled to.
+const epsilon = 0.5;
+const autoscrollMs = 180;
+export const scrollIntentKeys = new Set([
+    "ArrowDown",
+    "ArrowUp",
+    "End",
+    "Home",
+    "PageDown",
+    "PageUp",
+    " ",
+]);
+const noEdges = { start: false, end: false };
+const noVisibility = {
+    currentAnchorId: null,
+    visibleMessageIds: [],
+};
+function createStore(initial, equal) {
+    let value = initial;
+    const listeners = new Set();
+    return {
+        getSnapshot: () => value,
+        hasListeners: () => listeners.size > 0,
+        setSnapshot: (next) => {
+            if (equal(value, next))
+                return;
+            value = next;
+            listeners.forEach((listener) => listener());
+        },
+        subscribe: (listener, onFirst, onLast) => {
+            const first = listeners.size === 0;
+            listeners.add(listener);
+            if (first)
+                onFirst?.();
+            return () => {
+                listeners.delete(listener);
+                if (listeners.size === 0)
+                    onLast?.();
+            };
+        },
+    };
+}
+const sameEdges = (a, b) => a.start === b.start && a.end === b.end;
+const sameVisibility = (a, b) => a.currentAnchorId === b.currentAnchorId &&
+    a.visibleMessageIds.length === b.visibleMessageIds.length &&
+    a.visibleMessageIds.every((id, index) => id === b.visibleMessageIds[index]);
+const pixels = (value) => {
+    const number = Number.parseFloat(value ?? "");
+    return Number.isFinite(number) ? number : 0;
+};
+function blockPadding(element) {
+    if (!element)
+        return { start: 0, end: 0 };
+    const style = getComputedStyle(element);
+    return {
+        start: pixels(style.paddingBlockStart || style.paddingTop),
+        end: pixels(style.paddingBlockEnd || style.paddingBottom),
+    };
+}
+function rowGap(element) {
+    if (!element)
+        return 0;
+    const style = getComputedStyle(element);
+    return pixels(style.rowGap === "normal" ? style.gap : style.rowGap);
+}
+const isAnchor = (element) => element?.dataset.scrollAnchor === "true";
+function itemsOf(content, spacer) {
+    return Array.from(content.children).filter((child) => child instanceof HTMLElement && child !== spacer);
+}
+const offsetIn = (element, viewport) => element.getBoundingClientRect().top -
+    viewport.getBoundingClientRect().top +
+    viewport.scrollTop;
+const topIn = (element, viewport) => element.getBoundingClientRect().top - viewport.getBoundingClientRect().top;
+const maxScroll = (viewport) => Math.max(0, viewport.scrollHeight - viewport.clientHeight);
+function contentHeight(content, spacer, viewport) {
+    const padding = blockPadding(content);
+    const viewportTop = viewport.getBoundingClientRect().top;
+    let height = padding.start + padding.end;
+    for (const item of itemsOf(content, spacer))
+        height = Math.max(height, item.getBoundingClientRect().bottom -
+            viewportTop +
+            viewport.scrollTop +
+            padding.end);
+    return height;
+}
+export class MessageScrollerController {
+    options;
+    stateStore = createStore(noEdges, sameEdges);
+    visibilityStore = createStore(noVisibility, sameVisibility);
+    pendingDefaultStore;
+    preserveScrollOnPrepend = true;
+    root = null;
+    viewport = null;
+    content = null;
+    spacer = null;
+    spacerGap = 0;
+    spacerHeight = 0;
+    mode;
+    itemCount = 0;
+    firstItem = null;
+    lastScrollTop = 0;
+    autoscrolling = false;
+    autoscrollTimer = null;
+    streamingTurn = null;
+    pendingMessage = null;
+    prependRestore = null;
+    defaultApplied = false;
+    messages = new Map();
+    visibleIds = new Set();
+    handledAnchors = new WeakSet();
+    observer = null;
+    stateFrame = null;
+    visibilityFrame = null;
+    pendingFrame = null;
+    constructor(options) {
+        this.options = options;
+        this.mode = options.autoScroll ? "following-bottom" : "free-scrolling";
+        this.pendingDefaultStore = createStore(options.defaultScrollPosition === "end" ||
+            options.defaultScrollPosition === "last-anchor", Object.is);
+    }
+    setOptions(next) {
+        if (next.defaultScrollPosition !== this.options.defaultScrollPosition)
+            this.defaultApplied = false;
+        this.options = next;
+    }
+    // Elements
+    setRoot = (element) => {
+        this.root = element;
+        if (element)
+            this.applyAttributes(this.stateStore.getSnapshot());
+    };
+    setViewport = (element) => {
+        this.viewport = element;
+        if (element)
+            this.applyAttributes(this.stateStore.getSnapshot());
+    };
+    getViewport = () => this.viewport;
+    setContent = (element) => {
+        this.content = element;
+    };
+    setSpacer = (element) => {
+        this.spacer = element;
+        this.spacerGap = rowGap(element?.parentElement ?? null);
+    };
+    registerMessage = (messageId, element, previous) => {
+        if (element) {
+            this.messages.set(messageId, element);
+            this.observer?.observe(element);
+            this.scheduleVisibility();
+            if (this.pendingMessage?.messageId === messageId)
+                this.schedulePendingFlush();
+            return;
+        }
+        if (previous && this.messages.get(messageId) === previous) {
+            this.messages.delete(messageId);
+            this.visibleIds.delete(messageId);
+            this.observer?.unobserve(previous);
+            this.scheduleVisibility();
+        }
+    };
+    // Public scrolling
+    scrollToStart = ({ behavior = "auto", } = {}) => {
+        if (!this.viewport)
+            return false;
+        this.setSpacerHeight(0);
+        this.streamingTurn = null;
+        this.mode = "free-scrolling";
+        this.scrollViewportTo(0, { behavior });
+        this.scheduleVisibility();
+        return true;
+    };
+    scrollToEnd = ({ behavior = "auto" } = {}) => {
+        const viewport = this.viewport;
+        if (!viewport)
+            return false;
+        this.setSpacerHeight(0);
+        this.streamingTurn = null;
+        this.mode = this.options.autoScroll ? "following-bottom" : "free-scrolling";
+        this.scrollViewportTo(maxScroll(viewport), {
+            autoscrolling: true,
+            behavior,
+        });
+        this.scheduleVisibility();
+        return true;
+    };
+    scrollToMessage = (messageId, options) => {
+        const element = this.messages.get(messageId);
+        if (element) {
+            this.markDefaultApplied();
+            this.pendingMessage = this.scrollToElement(element, options)
+                ? null
+                : { messageId, options };
+            return true;
+        }
+        if (this.itemCount === 0) {
+            this.pendingMessage = { messageId, options };
+            this.markDefaultApplied();
+            return true;
+        }
+        return false;
+    };
+    // Events from the parts
+    userScrollIntent = () => {
+        if (this.mode !== "free-scrolling") {
+            this.streamingTurn = null;
+            this.mode = "free-scrolling";
+        }
+    };
+    syncAfterScroll = () => {
+        this.commit();
+        this.scheduleVisibility();
+        this.captureFirstVisible();
+    };
+    handleResize = () => {
+        if (this.mode === "following-bottom" && this.options.autoScroll) {
+            this.scrollToEnd();
+            return;
+        }
+        const previousSpacer = this.spacerHeight;
+        if (this.reanchor()) {
+            if (this.options.autoScroll &&
+                previousSpacer > 0 &&
+                this.spacerHeight === 0)
+                this.scrollToEnd();
+            return;
+        }
+        this.scheduleCommit();
+        this.scheduleVisibility();
+    };
+    handleContentChange = () => {
+        const content = this.content;
+        if (!content)
+            return;
+        const items = itemsOf(content, this.spacer);
+        const previousCount = this.itemCount;
+        const previousFirst = this.firstItem;
+        this.itemCount = items.length;
+        this.firstItem = items[0] ?? null;
+        this.applyContentChange(items, previousCount, previousFirst);
+        this.captureFirstVisible();
+    };
+    // Mount and option changes
+    applyDefaultOrSettle = () => {
+        if (!this.applyDefault() && this.itemCount === 0)
+            this.pendingDefaultStore.setSnapshot(false);
+    };
+    followOnAutoScroll = () => {
+        if (this.options.autoScroll &&
+            this.mode === "following-bottom" &&
+            this.itemCount > 0) {
+            this.scrollToEnd();
+            return;
+        }
+        this.commit();
+    };
+    observeVisibility = () => {
+        if (!this.viewport || !this.visibilityStore.hasListeners())
+            return;
+        if (typeof IntersectionObserver === "undefined") {
+            this.scheduleVisibility();
+            return;
+        }
+        if (!this.observer) {
+            const inset = this.options.scrollMargin + this.options.scrollPreviousItemPeek;
+            this.observer = new IntersectionObserver((entries) => {
+                for (const entry of entries) {
+                    const id = entry.target.dataset.messageId;
+                    if (!id)
+                        continue;
+                    if (entry.isIntersecting)
+                        this.visibleIds.add(id);
+                    else
+                        this.visibleIds.delete(id);
+                }
+                this.scheduleVisibility();
+            }, {
+                root: this.viewport,
+                rootMargin: `${-inset}px 0px 0px 0px`,
+                threshold: [0, 0.01, 0.5, 1],
+            });
+        }
+        this.messages.forEach((element) => this.observer?.observe(element));
+        this.scheduleVisibility();
+    };
+    unobserveVisibility = () => {
+        if (this.visibilityFrame !== null)
+            cancelAnimationFrame(this.visibilityFrame);
+        this.visibilityFrame = null;
+        this.observer?.disconnect();
+        this.observer = null;
+        this.visibleIds.clear();
+        this.visibilityStore.setSnapshot(noVisibility);
+    };
+    dispose = () => {
+        for (const frame of [
+            this.stateFrame,
+            this.visibilityFrame,
+            this.pendingFrame,
+        ])
+            if (frame !== null)
+                cancelAnimationFrame(frame);
+        this.stateFrame = this.visibilityFrame = this.pendingFrame = null;
+        if (this.autoscrollTimer !== null)
+            clearTimeout(this.autoscrollTimer);
+        this.autoscrollTimer = null;
+        this.observer?.disconnect();
+        this.observer = null;
+    };
+    // Internals
+    markDefaultApplied() {
+        this.defaultApplied = true;
+        this.pendingDefaultStore.setSnapshot(false);
+    }
+    applyContentChange(items, previousCount, previousFirst) {
+        if (this.flushPendingMessage())
+            return;
+        if (previousCount === 0) {
+            if (this.applyDefault() ||
+                (items.length > 0 && this.options.autoScroll && this.scrollToEnd()))
+                return;
+            this.commit();
+            this.scheduleVisibility();
+            return;
+        }
+        const firstIndex = previousFirst ? items.indexOf(previousFirst) : -1;
+        if (this.preserveScrollOnPrepend && firstIndex > 0) {
+            this.restorePrepend();
+            return;
+        }
+        if (items.length > previousCount) {
+            const anchor = items.slice(previousCount).find((item) => isAnchor(item));
+            if (anchor) {
+                const following = this.options.autoScroll && this.mode === "following-bottom";
+                if (following &&
+                    items.slice(previousCount).filter((item) => isAnchor(item)).length > 1) {
+                    this.scrollToEnd();
+                    return;
+                }
+                this.pinAnchor(anchor);
+                return;
+            }
+        }
+        if (items.length === previousCount) {
+            const anchor = items.find((item) => isAnchor(item) && !this.handledAnchors.has(item));
+            if (anchor) {
+                this.pinAnchor(anchor);
+                return;
+            }
+        }
+        if (this.mode === "following-bottom" && this.options.autoScroll)
+            this.scrollToEnd();
+        else {
+            this.commit();
+            this.scheduleVisibility();
+        }
+    }
+    pinAnchor(anchor) {
+        this.scrollToElement(anchor, { align: "start" }, true);
+        this.handledAnchors.add(anchor);
+    }
+    applyDefault() {
+        const position = this.options.defaultScrollPosition;
+        if (this.defaultApplied || this.itemCount === 0)
+            return false;
+        let done = false;
+        if (position === "last-anchor") {
+            const content = this.content;
+            const viewport = this.viewport;
+            const anchor = content && viewport
+                ? itemsOf(content, this.spacer).filter(isAnchor).pop()
+                : undefined;
+            if (!content || !viewport || !anchor)
+                done = this.scrollToEnd();
+            else
+                done = this.measuringFrom(anchor, () => contentHeight(content, this.spacer, viewport) -
+                    offsetIn(anchor, viewport) <=
+                    viewport.clientHeight
+                    ? this.scrollToEnd()
+                    : this.scrollToElement(anchor, { align: "start" }, true));
+        }
+        else
+            done = position === "end" ? this.scrollToEnd() : this.scrollToStart();
+        if (done)
+            this.markDefaultApplied();
+        return done;
+    }
+    scrollToElement(element, options = {}, keepPreviousPeek = false) {
+        const content = this.content;
+        const viewport = this.viewport;
+        if (!content || !viewport || !content.contains(element))
+            return false;
+        const { align = "start", behavior = "auto", scrollMargin = this.options.scrollMargin, } = options;
+        const top = this.targetTop(element, align, keepPreviousPeek
+            ? scrollMargin + this.options.scrollPreviousItemPeek
+            : scrollMargin);
+        this.setSpacerHeight(top +
+            viewport.clientHeight -
+            this.measuringFrom(element, () => contentHeight(content, this.spacer, viewport)));
+        this.prependRestore = { element, viewportTop: topIn(element, viewport) };
+        this.mode = keepPreviousPeek ? "anchored-to-message" : "settling-jump";
+        this.streamingTurn = keepPreviousPeek ? element : null;
+        this.scrollViewportTo(top, { behavior });
+        this.scheduleVisibility();
+        return true;
+    }
+    /** Off-screen items report a 10rem estimate under `content-visibility: auto`; lay out `from` and every later item at real size while measuring. */
+    measuringFrom(from, measure) {
+        const items = this.content ? itemsOf(this.content, this.spacer) : [];
+        const later = items.slice(Math.max(0, items.indexOf(from)));
+        const previous = later.map((item) => item.style.contentVisibility);
+        for (const item of later)
+            item.style.contentVisibility = "visible";
+        try {
+            return measure();
+        }
+        finally {
+            later.forEach((item, index) => (item.style.contentVisibility = previous[index] ?? ""));
+        }
+    }
+    targetTop(element, align, margin) {
+        const viewport = this.viewport;
+        const offset = offsetIn(element, viewport);
+        const height = element.getBoundingClientRect().height;
+        const padding = blockPadding(this.spacer?.parentElement);
+        if (align === "center") {
+            const room = Math.max(0, viewport.clientHeight - padding.start - padding.end);
+            return offset - padding.start - (room - height) / 2 - margin;
+        }
+        if (align === "end")
+            return offset - viewport.clientHeight + height + padding.end + margin;
+        if (align === "nearest") {
+            const top = viewport.scrollTop + padding.start;
+            const bottom = viewport.scrollTop + viewport.clientHeight - padding.end;
+            if (offset >= top && offset + height <= bottom)
+                return viewport.scrollTop;
+            return offset < top
+                ? offset - padding.start - margin
+                : offset + height - viewport.clientHeight + padding.end + margin;
+        }
+        return offset - padding.start - margin;
+    }
+    reanchor() {
+        const element = this.streamingTurn;
+        if (!element || !element.isConnected || this.mode !== "anchored-to-message")
+            return false;
+        return this.scrollToElement(element, { align: "start" }, true);
+    }
+    flushPendingMessage() {
+        const pending = this.pendingMessage;
+        if (!pending)
+            return false;
+        const element = this.messages.get(pending.messageId);
+        if (!element || !this.scrollToElement(element, pending.options))
+            return false;
+        this.pendingMessage = null;
+        this.markDefaultApplied();
+        return true;
+    }
+    schedulePendingFlush() {
+        if (this.pendingFrame !== null)
+            return;
+        this.pendingFrame = requestAnimationFrame(() => {
+            this.pendingFrame = null;
+            if (this.flushPendingMessage())
+                this.captureFirstVisible();
+        });
+    }
+    setSpacerHeight(value) {
+        const spacer = this.spacer;
+        if (!spacer)
+            return;
+        const height = Math.max(0, Math.ceil(value));
+        if (this.spacerHeight === height)
+            return;
+        this.spacerHeight = height;
+        spacer.hidden = height === 0;
+        spacer.style.height = `${height}px`;
+        spacer.style.marginTop = height > 0 ? `${-this.spacerGap}px` : "";
+    }
+    setAutoscrolling(on) {
+        if (this.autoscrollTimer !== null)
+            clearTimeout(this.autoscrollTimer);
+        this.autoscrollTimer = null;
+        if (this.autoscrolling !== on) {
+            this.autoscrolling = on;
+            this.commit();
+        }
+        if (on)
+            this.autoscrollTimer = window.setTimeout(() => {
+                this.autoscrollTimer = null;
+                this.autoscrolling = false;
+                this.commit();
+            }, autoscrollMs);
+    }
+    scrollViewportTo(value, { behavior = "auto", autoscrolling = false, } = {}) {
+        const viewport = this.viewport;
+        if (!viewport)
+            return;
+        const top = Math.max(0, value);
+        if (Math.abs(viewport.scrollTop - top) <= epsilon) {
+            viewport.scrollTop = top;
+            this.commit();
+            return;
+        }
+        if (autoscrolling)
+            this.setAutoscrolling(true);
+        viewport.scrollTo({ top, behavior });
+        this.scheduleCommit();
+    }
+    restorePrepend() {
+        const restore = this.prependRestore;
+        const viewport = this.viewport;
+        if (!restore || !viewport || !restore.element.isConnected)
+            return false;
+        const delta = topIn(restore.element, viewport) - restore.viewportTop;
+        if (Math.abs(delta) <= epsilon)
+            return false;
+        viewport.scrollTop += delta;
+        restore.viewportTop = topIn(restore.element, viewport);
+        this.scheduleCommit();
+        this.scheduleVisibility();
+        return true;
+    }
+    captureFirstVisible() {
+        const content = this.content;
+        const viewport = this.viewport;
+        if (!content || !viewport) {
+            this.prependRestore = null;
+            return;
+        }
+        const bounds = viewport.getBoundingClientRect();
+        const first = itemsOf(content, this.spacer).find((item) => {
+            if (!item.dataset.messageId)
+                return false;
+            const rect = item.getBoundingClientRect();
+            return rect.bottom > bounds.top && rect.top < bounds.bottom;
+        });
+        this.prependRestore = first
+            ? { element: first, viewportTop: topIn(first, viewport) }
+            : null;
+    }
+    readEdges() {
+        const { content, viewport } = this;
+        if (!content || !viewport)
+            return noEdges;
+        const threshold = this.options.scrollEdgeThreshold;
+        const height = contentHeight(content, this.spacer, viewport);
+        return {
+            start: viewport.scrollTop > threshold,
+            end: height - viewport.scrollTop - viewport.clientHeight > threshold,
+        };
+    }
+    updateMode(edges) {
+        const top = this.viewport?.scrollTop ?? 0;
+        const scrolledUp = top < this.lastScrollTop - epsilon;
+        this.lastScrollTop = top;
+        if (this.options.autoScroll &&
+            !edges.end &&
+            this.mode !== "settling-jump" &&
+            this.mode !== "anchored-to-message")
+            this.mode = "following-bottom";
+        else if (this.mode === "following-bottom" &&
+            edges.end &&
+            scrolledUp &&
+            !this.autoscrolling)
+            this.mode = "free-scrolling";
+    }
+    applyAttributes(edges) {
+        const value = [edges.start && "start", edges.end && "end"]
+            .filter(Boolean)
+            .join(" ");
+        for (const element of [this.root, this.viewport]) {
+            if (!element)
+                continue;
+            if (value)
+                element.setAttribute("data-scrollable", value);
+            else
+                element.removeAttribute("data-scrollable");
+            element.toggleAttribute("data-autoscrolling", this.autoscrolling);
+        }
+    }
+    commit() {
+        const edges = this.readEdges();
+        this.updateMode(edges);
+        const shown = this.mode === "following-bottom" ? { ...edges, end: false } : edges;
+        this.applyAttributes(shown);
+        this.stateStore.setSnapshot(shown);
+    }
+    scheduleCommit() {
+        if (this.stateFrame !== null)
+            return;
+        this.stateFrame = requestAnimationFrame(() => {
+            this.stateFrame = null;
+            this.commit();
+        });
+    }
+    scheduleVisibility() {
+        if (!this.visibilityStore.hasListeners() || this.visibilityFrame !== null)
+            return;
+        this.visibilityFrame = requestAnimationFrame(() => {
+            this.visibilityFrame = null;
+            if (this.visibilityStore.hasListeners())
+                this.visibilityStore.setSnapshot(this.readVisibility());
+        });
+    }
+    readVisibility() {
+        const { content, viewport } = this;
+        if (!content || !viewport)
+            return noVisibility;
+        const bounds = viewport.getBoundingClientRect();
+        const line = bounds.top +
+            this.options.scrollMargin +
+            this.options.scrollPreviousItemPeek;
+        const measure = typeof IntersectionObserver === "undefined";
+        const visibleMessageIds = [];
+        let currentAnchorId = null;
+        for (const item of itemsOf(content, this.spacer)) {
+            const id = item.dataset.messageId;
+            if (!id)
+                continue;
+            const anchor = isAnchor(item);
+            const rect = anchor || measure ? item.getBoundingClientRect() : null;
+            const visible = measure && rect
+                ? rect.bottom > line && rect.top < bounds.bottom
+                : this.visibleIds.has(id);
+            if (visible)
+                visibleMessageIds.push(id);
+            if (anchor && rect && rect.top <= line + epsilon)
+                currentAnchorId = id;
+        }
+        return visibleMessageIds.length === 0 && currentAnchorId === null
+            ? noVisibility
+            : { currentAnchorId, visibleMessageIds };
+    }
+}

package/dist/internal/pressable.d.ts

@@ -0,0 +1,2 @@
+import { Button } from "@base-ui/react/button";
+export declare function Pressable({ nativeButton, render, ref, className, disabled, focusableWhenDisabled, onClick, ...props }: Button.Props): import("react").JSX.Element | null;

package/dist/internal/pressable.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Button } from "@base-ui/react/button";
+import { useRender } from "@base-ui/react/use-render";
+// Base UI gives non-native renders role="button"; navigation needs real link semantics.
+export function Pressable({ nativeButton = true, render, ref, className, disabled = false, focusableWhenDisabled = false, onClick, ...props }) {
+    const link = useRender({
+        enabled: !nativeButton,
+        defaultTagName: "a",
+        render,
+        ref,
+        state: { disabled },
+        props: {
+            ...props,
+            className: typeof className === "function" ? className({ disabled }) : className,
+            "aria-disabled": disabled || undefined,
+            tabIndex: disabled && !focusableWhenDisabled ? -1 : props.tabIndex,
+            onClick: ((event) => {
+                if (disabled) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+                onClick?.(event);
+            }),
+        },
+    });
+    return nativeButton ? (_jsx(Button, { ...props, render: render, ref: ref, className: className, disabled: disabled, focusableWhenDisabled: focusableWhenDisabled, onClick: onClick })) : (link);
+}

package/dist/internal/syntax.d.ts

@@ -0,0 +1,14 @@
+import type { ThemedToken } from "shiki/core";
+import { type CodeLanguage } from "./languages.js";
+/** The Shiki language for a file name, from its whole name or its extension. */
+export declare function languageForFilename(name: string): CodeLanguage | null;
+/** Resolves a language name or alias, falling back to the file name. `null` means plain text. */
+export declare function resolveCodeLanguage(language: string | undefined, filename?: string): CodeLanguage | null;
+/** Longer code renders as plain text, so one huge file cannot freeze the page. */
+export declare const maxHighlightedLength = 200000;
+export declare function loadCodeLanguage(language: CodeLanguage): Promise<void>;
+/** Languages a file needs beyond its own, such as the fences inside Markdown. */
+export declare function embeddedLanguages(code: string, language: CodeLanguage): ("html" | "ruby" | "rel" | "go" | "log" | "move" | "d" | "r" | "abap" | "actionscript-3" | "ada" | "ahk" | "ahk2" | "angular-html" | "angular-ts" | "apache" | "apex" | "apl" | "applescript" | "ara" | "asciidoc" | "asm" | "astro" | "awk" | "ballerina" | "bat" | "beancount" | "berry" | "bibtex" | "bicep" | "bird2" | "blade" | "bsl" | "c" | "c3" | "cadence" | "cairo" | "chapel" | "clarity" | "clojure" | "cmake" | "cobol" | "codeowners" | "codeql" | "coffee" | "common-lisp" | "coq" | "cpp" | "crystal" | "csharp" | "css" | "csv" | "cue" | "cypher" | "dart" | "dax" | "desktop" | "diff" | "docker" | "dotenv" | "dream-maker" | "edge" | "elixir" | "elm" | "emacs-lisp" | "erb" | "erlang" | "fennel" | "fish" | "fluent" | "fortran-fixed-form" | "fortran-free-form" | "fsharp" | "gdresource" | "gdscript" | "gdshader" | "genie" | "gherkin" | "git-commit" | "git-rebase" | "gleam" | "glimmer-js" | "glimmer-ts" | "glsl" | "gn" | "gnuplot" | "graphql" | "groovy" | "hack" | "haml" | "handlebars" | "haskell" | "haxe" | "hcl" | "hjson" | "hlsl" | "html-derivative" | "http" | "hurl" | "hxml" | "hy" | "imba" | "ini" | "java" | "javascript" | "jinja" | "jison" | "json" | "json5" | "jsonc" | "jsonl" | "jsonnet" | "jssm" | "jsx" | "julia" | "just" | "kdl" | "kotlin" | "kusto" | "latex" | "lean" | "less" | "liquid" | "llvm" | "logo" | "lua" | "luau" | "make" | "markdown" | "marko" | "matlab" | "mdc" | "mdx" | "mermaid" | "mipsasm" | "mojo" | "moonbit" | "narrat" | "nextflow" | "nextflow-groovy" | "nginx" | "nim" | "nix" | "nsis" | "nushell" | "objective-c" | "objective-cpp" | "ocaml" | "odin" | "openscad" | "org" | "pascal" | "perl" | "php" | "pkl" | "plsql" | "po" | "polar" | "postcss" | "powerquery" | "powershell" | "prisma" | "prolog" | "proto" | "pug" | "puppet" | "purescript" | "python" | "qml" | "qmldir" | "qss" | "racket" | "raku" | "razor" | "rbs" | "reg" | "regexp" | "riscv" | "ron" | "rosmsg" | "rst" | "rust" | "sas" | "sass" | "scala" | "scheme" | "scss" | "sdbl" | "shaderlab" | "shellscript" | "shellsession" | "smalltalk" | "smithy" | "solidity" | "soy" | "sparql" | "splunk" | "sql" | "ssh-config" | "stata" | "stylus" | "surrealql" | "svelte" | "swift" | "system-verilog" | "systemd" | "talonscript" | "tasl" | "tcl" | "templ" | "terraform" | "tex" | "toml" | "ts-tags" | "tsv" | "tsx" | "turtle" | "twig" | "typescript" | "typespec" | "typst" | "v" | "vala" | "vb" | "verilog" | "vhdl" | "viml" | "vue" | "vue-html" | "vue-vine" | "vyper" | "wasm" | "wenyan" | "wgsl" | "wikitext" | "wit" | "wolfram" | "xml" | "xsl" | "yaml" | "zenscript" | "zig")[];
+export declare function isLanguageReady(language: CodeLanguage): boolean;
+/** Tokens when the language is already loaded, otherwise `null`. */
+export declare function codeTokens(code: string, language: CodeLanguage): ThemedToken[][] | null;