@svelterm/core 0.1.0

package/dist/src/render/paint-text.js

@@ -0,0 +1,120 @@
+import { wrapText, truncateText } from '../layout/text.js';
+/**
+ * Paint a text node's content into the buffer, respecting inherited
+ * text-align, white-space, text-overflow from ancestors.
+ */
+export function paintTextContent(node, buffer, box, visuals, styles, layout, clip) {
+    const text = node.text ?? '';
+    if (!text)
+        return;
+    if (box.width === 0 && box.height === 0)
+        return;
+    // Find text properties from the ancestor that sets them
+    const alignResult = findAncestorWithBox(node, styles, layout, s => s.textAlign !== 'left' ? s.textAlign : undefined);
+    const align = alignResult?.value ?? 'left';
+    const whiteSpace = findAncestorProp(node, styles, s => s.whiteSpace !== 'normal' ? s.whiteSpace : undefined) ?? 'normal';
+    const textOverflow = findAncestorProp(node, styles, s => s.textOverflow !== 'clip' ? s.textOverflow : undefined) ?? 'clip';
+    const noWrap = whiteSpace === 'nowrap';
+    const ellipsis = textOverflow === 'ellipsis';
+    // For truncation, use the alignment container's inner width
+    const alignBox = alignResult?.box;
+    const parentBox = node.parent ? layout.get(node.parent.id) : undefined;
+    const truncWidth = alignBox ? innerWidth(alignBox, node, styles, layout) : (parentBox?.width ?? box.width);
+    // Determine text lines
+    let lines;
+    if (noWrap && ellipsis) {
+        lines = [truncateText(text, truncWidth)];
+    }
+    else if (noWrap) {
+        lines = [text.substring(0, truncWidth)];
+    }
+    else {
+        lines = wrapText(text, box.width > 0 ? box.width : buffer.width);
+    }
+    // Compute starting x with text-align
+    let startX = box.x;
+    if (align !== 'left' && alignBox) {
+        const inW = innerWidth(alignBox, node, styles, layout);
+        const inX = innerX(alignBox, node, styles, layout);
+        const textWidth = lines[0]?.length ?? 0;
+        if (align === 'center') {
+            startX = inX + Math.floor((inW - textWidth) / 2);
+        }
+        else if (align === 'right') {
+            startX = inX + inW - textWidth;
+        }
+    }
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        const y = box.y + lineIdx;
+        for (let i = 0; i < line.length; i++) {
+            const cx = startX + i;
+            if (clip && (cx < clip.x || cx >= clip.x + clip.width || y < clip.y || y >= clip.y + clip.height))
+                continue;
+            buffer.setCell(cx, y, {
+                char: line[i],
+                fg: visuals.fg,
+                bg: visuals.bg,
+                bold: visuals.bold,
+                italic: visuals.italic,
+                underline: visuals.underline,
+                strikethrough: visuals.strikethrough,
+                dim: visuals.dim,
+                hyperlink: visuals.hyperlink,
+            });
+        }
+    }
+}
+/** Find an ancestor property value and the ancestor's layout box. */
+function findAncestorWithBox(node, styles, layout, getter) {
+    let current = node.parent;
+    while (current) {
+        const s = styles.get(current.id);
+        if (s) {
+            const val = getter(s);
+            if (val !== undefined) {
+                const box = layout.get(current.id);
+                if (box)
+                    return { value: val, box };
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/** Find an ancestor property value (without needing the box). */
+function findAncestorProp(node, styles, getter) {
+    let current = node.parent;
+    while (current) {
+        const s = styles.get(current.id);
+        if (s) {
+            const val = getter(s);
+            if (val !== undefined)
+                return val;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/** Get inner X position (accounting for border) of the alignment container. */
+function innerX(alignBox, node, styles, layout) {
+    const inset = findBorderInset(alignBox, node, styles, layout);
+    return alignBox.x + inset;
+}
+/** Get inner width (accounting for border) of the alignment container. */
+function innerWidth(alignBox, node, styles, layout) {
+    const inset = findBorderInset(alignBox, node, styles, layout);
+    return alignBox.width - inset * 2;
+}
+/** Find the border inset of the ancestor that owns alignBox. */
+function findBorderInset(alignBox, node, styles, layout) {
+    let current = node.parent;
+    while (current) {
+        if (layout.get(current.id) === alignBox) {
+            const s = styles.get(current.id);
+            return (s?.borderStyle && s.borderStyle !== 'none') ? 1 : 0;
+        }
+        current = current.parent;
+    }
+    return 0;
+}

package/dist/src/render/paint.d.ts

@@ -0,0 +1,5 @@
+import { TermNode } from '../renderer/node.js';
+import { CellBuffer } from './buffer.js';
+import { ResolvedStyle } from '../css/compute.js';
+import { LayoutBox } from '../layout/engine.js';
+export declare function paint(root: TermNode, buffer: CellBuffer, styles?: Map<number, ResolvedStyle>, layout?: Map<number, LayoutBox>): void;

package/dist/src/render/paint.js

@@ -0,0 +1,220 @@
+import { renderBorder } from './border.js';
+import { paintTextContent } from './paint-text.js';
+const DEFAULT_VISUALS = {
+    fg: 'default', bg: 'default',
+    bold: false, italic: false, underline: false, strikethrough: false, dim: false,
+};
+const NO_SCROLL = { x: 0, y: 0 };
+export function paint(root, buffer, styles, layout) {
+    paintNode(root, buffer, styles, layout, DEFAULT_VISUALS, null, NO_SCROLL);
+}
+function paintNode(node, buffer, styles, layout, inherited, clip, scroll) {
+    if (node.nodeType === 'comment')
+        return;
+    const visuals = resolveVisuals(node, styles, inherited);
+    const rawBox = layout?.get(node.id);
+    const box = rawBox ? applyScroll(rawBox, scroll) : undefined;
+    // Check display:none — element and all descendants are invisible and take no space
+    const ownStyle = node.nodeType === 'element' ? styles?.get(node.id) : undefined;
+    const parentStyle = node.parent ? styles?.get(node.parent.id) : undefined;
+    if (ownStyle?.display === 'none' || parentStyle?.display === 'none')
+        return;
+    // Check visibility — hidden elements take space but don't render
+    const isHidden = ownStyle?.visibility === 'hidden' || parentStyle?.visibility === 'hidden';
+    if (node.nodeType === 'text') {
+        if (!isHidden) {
+            const parentBox = node.parent ? layout?.get(node.parent.id) : undefined;
+            paintText(node, buffer, box, visuals, clip, parentStyle, parentBox, styles, layout);
+        }
+        return;
+    }
+    if (node.nodeType === 'element' && box && !isHidden) {
+        fillBackground(buffer, box, visuals, clip);
+        if (ownStyle && ownStyle.borderStyle !== 'none') {
+            renderBorder(buffer, box, ownStyle);
+        }
+        if (node.tag === 'hr') {
+            paintHorizontalRule(buffer, box, visuals, clip);
+            return;
+        }
+        if (node.tag === 'li') {
+            paintListMarker(node, buffer, box, visuals, clip);
+        }
+        if (node.tag === 'input' && box) {
+            paintInput(node, buffer, box, visuals, clip);
+        }
+    }
+    // Determine clip and scroll for children
+    let childClip = clip;
+    let childScroll = scroll;
+    if (node.nodeType === 'element' && box) {
+        const ownStyle = styles?.get(node.id);
+        if (ownStyle && ownStyle.overflow !== 'visible') {
+            childClip = intersectClip(clip, box);
+        }
+        if (node.scrollTop !== 0 || node.scrollLeft !== 0) {
+            childScroll = { x: scroll.x + node.scrollLeft, y: scroll.y + node.scrollTop };
+        }
+    }
+    for (const child of node.children) {
+        paintNode(child, buffer, styles, layout, visuals, childClip, childScroll);
+    }
+}
+function applyScroll(box, scroll) {
+    if (scroll.x === 0 && scroll.y === 0)
+        return box;
+    return { x: box.x - scroll.x, y: box.y - scroll.y, width: box.width, height: box.height };
+}
+function paintText(node, buffer, box, visuals, clip, parentStyle, parentBox, styles, layout) {
+    if (!box || !styles || !layout)
+        return;
+    paintTextContent(node, buffer, box, visuals, styles, layout, clip);
+}
+function fillBackground(buffer, box, visuals, clip) {
+    if (visuals.bg === 'default')
+        return;
+    for (let row = box.y; row < box.y + box.height; row++) {
+        for (let col = box.x; col < box.x + box.width; col++) {
+            if (clip && !inClip(col, row, clip))
+                continue;
+            buffer.setCell(col, row, { bg: visuals.bg });
+        }
+    }
+}
+function paintListMarker(node, buffer, box, visuals, clip) {
+    const parent = node.parent;
+    if (!parent)
+        return;
+    const isOrdered = parent.tag === 'ol';
+    let marker;
+    if (isOrdered) {
+        const index = parent.children.filter(c => c.tag === 'li').indexOf(node);
+        marker = `${index + 1}. `;
+    }
+    else {
+        marker = '• ';
+    }
+    for (let i = 0; i < marker.length; i++) {
+        const cx = box.x + i;
+        if (clip && !inClip(cx, box.y, clip))
+            continue;
+        buffer.setCell(cx, box.y, { char: marker[i], fg: visuals.fg, dim: visuals.dim });
+    }
+}
+function paintInput(node, buffer, box, visuals, clip) {
+    const value = node.attributes.get('value') ?? '';
+    const isFocused = node.attributes.has('data-focused');
+    const cursor = node.textBuffer?.cursor ?? value.length;
+    const style = node.cache.resolvedStyle;
+    const borderInset = (style?.borderStyle && style.borderStyle !== 'none') ? 1 : 0;
+    const padL = resolvePadVal(style?.paddingLeft) + borderInset;
+    const padR = resolvePadVal(style?.paddingRight) + borderInset;
+    const contentX = box.x + padL;
+    const contentY = box.y + borderInset;
+    const contentW = box.width - padL - padR;
+    if (contentW <= 0)
+        return;
+    // Scroll offset: only adjust when cursor leaves visible range.
+    // Cursor at end of text (position == value.length) can sit 1 cell
+    // past the last character, using the right padding space.
+    let scrollOffset = node.scrollLeft ?? 0;
+    // Cursor scrolled off the left → snap left edge to cursor
+    if (cursor < scrollOffset) {
+        scrollOffset = cursor;
+    }
+    // Cursor scrolled off the right → scroll just enough to show it
+    if (cursor > scrollOffset + contentW) {
+        scrollOffset = cursor - contentW;
+    }
+    // If cursor is mid-text and at the rightmost visible cell,
+    // we need to be able to see what's after it
+    if (cursor < value.length && cursor === scrollOffset + contentW) {
+        scrollOffset = cursor - contentW + 1;
+    }
+    scrollOffset = Math.max(0, scrollOffset);
+    node.scrollLeft = scrollOffset;
+    // Determine what's visible and where overflow indicators go
+    const hasOverflowLeft = scrollOffset > 0;
+    const visibleEnd = Math.min(scrollOffset + contentW, value.length);
+    const hasOverflowRight = visibleEnd < value.length;
+    // Paint text — overflow indicators replace the first/last visible character
+    for (let i = 0; i < contentW; i++) {
+        const charIdx = scrollOffset + i;
+        if (charIdx >= value.length)
+            break;
+        const cx = contentX + i;
+        if (clip && !inClip(cx, contentY, clip))
+            continue;
+        buffer.setCell(cx, contentY, { char: value[charIdx], fg: visuals.fg });
+    }
+    // Overflow indicators (faint ellipsis on top of first/last char)
+    if (hasOverflowLeft) {
+        const cx = contentX;
+        if (!clip || inClip(cx, contentY, clip)) {
+            buffer.setCell(cx, contentY, { char: '…', fg: visuals.fg, dim: true });
+        }
+    }
+    if (hasOverflowRight) {
+        const cx = contentX + contentW - 1;
+        if (!clip || inClip(cx, contentY, clip)) {
+            buffer.setCell(cx, contentY, { char: '…', fg: visuals.fg, dim: true });
+        }
+    }
+    // Cursor (inverted colors)
+    if (isFocused) {
+        const cursorScreenX = contentX + (cursor - scrollOffset);
+        if (cursorScreenX >= contentX && cursorScreenX <= contentX + contentW) {
+            const cursorChar = cursor < value.length ? value[cursor] : ' ';
+            if (!clip || inClip(cursorScreenX, contentY, clip)) {
+                buffer.setCell(cursorScreenX, contentY, {
+                    char: cursorChar,
+                    fg: visuals.bg !== 'default' ? visuals.bg : 'black',
+                    bg: visuals.fg !== 'default' ? visuals.fg : 'white',
+                });
+            }
+        }
+    }
+}
+function resolvePadVal(v) {
+    if (typeof v === 'number')
+        return v;
+    return 0;
+}
+function paintHorizontalRule(buffer, box, visuals, clip) {
+    for (let col = box.x; col < box.x + box.width; col++) {
+        if (clip && !inClip(col, box.y, clip))
+            continue;
+        buffer.setCell(col, box.y, { char: '─', fg: visuals.fg, dim: true });
+    }
+}
+function inClip(col, row, clip) {
+    return col >= clip.x && col < clip.x + clip.width
+        && row >= clip.y && row < clip.y + clip.height;
+}
+function intersectClip(existing, box) {
+    if (!existing)
+        return { x: box.x, y: box.y, width: box.width, height: box.height };
+    const x = Math.max(existing.x, box.x);
+    const y = Math.max(existing.y, box.y);
+    const right = Math.min(existing.x + existing.width, box.x + box.width);
+    const bottom = Math.min(existing.y + existing.height, box.y + box.height);
+    return { x, y, width: Math.max(0, right - x), height: Math.max(0, bottom - y) };
+}
+function resolveVisuals(node, styles, inherited) {
+    if (node.nodeType !== 'element')
+        return inherited;
+    const own = styles?.get(node.id);
+    if (!own)
+        return inherited;
+    const hyperlink = node.tag === 'a' ? node.attributes.get('href') : inherited.hyperlink;
+    return {
+        fg: own.fg !== 'default' ? own.fg : inherited.fg,
+        bg: own.bg !== 'default' ? own.bg : inherited.bg,
+        bold: own.bold || inherited.bold,
+        italic: own.italic || inherited.italic,
+        underline: own.underline || inherited.underline,
+        strikethrough: own.strikethrough || inherited.strikethrough,
+        dim: own.dim || inherited.dim,
+        hyperlink,
+    };
+}

package/dist/src/render/queue.d.ts

@@ -0,0 +1,24 @@
+import { TermNode } from '../renderer/node.js';
+export declare class RenderQueue {
+    paintOnly: Set<TermNode>;
+    styleResolve: Set<TermNode>;
+    layoutSubtree: Set<TermNode>;
+    layoutBubble: Set<TermNode>;
+    fullRecompute: boolean;
+    enqueuePaintOnly(node: TermNode): void;
+    enqueueStyleResolve(node: TermNode): void;
+    enqueueLayoutSubtree(node: TermNode): void;
+    enqueueLayoutBubble(node: TermNode): void;
+    setFullRecompute(): void;
+    isEmpty(): boolean;
+    clear(): void;
+    /** Returns a frozen copy of the current state and clears this queue. */
+    snapshot(): RenderQueueSnapshot;
+}
+export interface RenderQueueSnapshot {
+    readonly paintOnly: Set<TermNode>;
+    readonly styleResolve: Set<TermNode>;
+    readonly layoutSubtree: Set<TermNode>;
+    readonly layoutBubble: Set<TermNode>;
+    readonly fullRecompute: boolean;
+}

package/dist/src/render/queue.js

@@ -0,0 +1,54 @@
+export class RenderQueue {
+    paintOnly = new Set();
+    styleResolve = new Set();
+    layoutSubtree = new Set();
+    layoutBubble = new Set();
+    fullRecompute = false;
+    enqueuePaintOnly(node) {
+        // Don't add if already queued for more comprehensive work
+        if (this.styleResolve.has(node) || this.layoutSubtree.has(node) || this.layoutBubble.has(node))
+            return;
+        this.paintOnly.add(node);
+    }
+    enqueueStyleResolve(node) {
+        this.paintOnly.delete(node); // style resolve subsumes paint
+        this.styleResolve.add(node);
+    }
+    enqueueLayoutSubtree(node) {
+        this.paintOnly.delete(node); // layout subsumes paint
+        this.layoutSubtree.add(node);
+    }
+    enqueueLayoutBubble(node) {
+        this.paintOnly.delete(node);
+        this.layoutBubble.add(node);
+    }
+    setFullRecompute() {
+        this.fullRecompute = true;
+    }
+    isEmpty() {
+        return !this.fullRecompute
+            && this.paintOnly.size === 0
+            && this.styleResolve.size === 0
+            && this.layoutSubtree.size === 0
+            && this.layoutBubble.size === 0;
+    }
+    clear() {
+        this.paintOnly.clear();
+        this.styleResolve.clear();
+        this.layoutSubtree.clear();
+        this.layoutBubble.clear();
+        this.fullRecompute = false;
+    }
+    /** Returns a frozen copy of the current state and clears this queue. */
+    snapshot() {
+        const snap = {
+            paintOnly: new Set(this.paintOnly),
+            styleResolve: new Set(this.styleResolve),
+            layoutSubtree: new Set(this.layoutSubtree),
+            layoutBubble: new Set(this.layoutBubble),
+            fullRecompute: this.fullRecompute,
+        };
+        this.clear();
+        return snap;
+    }
+}

package/dist/src/render/scrollbar.d.ts

@@ -0,0 +1,3 @@
+import { CellBuffer } from './buffer.js';
+import { LayoutBox } from '../layout/engine.js';
+export declare function renderScrollbar(buffer: CellBuffer, box: LayoutBox, contentHeight: number, scrollTop: number): void;

package/dist/src/render/scrollbar.js

@@ -0,0 +1,19 @@
+const TRACK_CHAR = '│';
+const THUMB_CHAR = '┃';
+export function renderScrollbar(buffer, box, contentHeight, scrollTop) {
+    if (contentHeight <= box.height)
+        return;
+    const col = box.x + box.width - 1;
+    const trackHeight = box.height;
+    const thumbSize = Math.max(1, Math.round(trackHeight * (box.height / contentHeight)));
+    const maxScroll = contentHeight - box.height;
+    const thumbPos = Math.round((scrollTop / maxScroll) * (trackHeight - thumbSize));
+    for (let row = 0; row < trackHeight; row++) {
+        const isThumb = row >= thumbPos && row < thumbPos + thumbSize;
+        buffer.setCell(col, box.y + row, {
+            char: isThumb ? THUMB_CHAR : TRACK_CHAR,
+            fg: isThumb ? 'white' : 'default',
+            dim: !isThumb,
+        });
+    }
+}

package/dist/src/render/snapshot.d.ts

@@ -0,0 +1,18 @@
+import { CellBuffer } from './buffer.js';
+/**
+ * Serialize a cell buffer to a readable text format for snapshot testing.
+ * Each line shows the characters, followed by color/style annotations for non-default cells.
+ */
+export declare function bufferToText(buffer: CellBuffer): string;
+/**
+ * Serialize a cell buffer to a detailed format that includes style info.
+ * Format: each non-default cell shows [col,row char fg bg bold]
+ */
+export declare function bufferToStyledText(buffer: CellBuffer): string;
+/**
+ * Render a cell buffer to SVG for visual inspection.
+ */
+export declare function bufferToSvg(buffer: CellBuffer, options?: {
+    cellWidth?: number;
+    cellHeight?: number;
+}): string;

package/dist/src/render/snapshot.js

@@ -0,0 +1,126 @@
+/**
+ * Serialize a cell buffer to a readable text format for snapshot testing.
+ * Each line shows the characters, followed by color/style annotations for non-default cells.
+ */
+export function bufferToText(buffer) {
+    const lines = [];
+    for (let row = 0; row < buffer.height; row++) {
+        let line = '';
+        let hasContent = false;
+        for (let col = 0; col < buffer.width; col++) {
+            const cell = buffer.getCell(col, row);
+            line += cell.char;
+            if (cell.char !== ' ' || cell.bg !== 'default')
+                hasContent = true;
+        }
+        if (hasContent) {
+            lines.push(line.trimEnd());
+        }
+        else if (lines.length > 0) {
+            // Track empty lines between content, but trim trailing empties
+            lines.push('');
+        }
+    }
+    // Trim trailing empty lines
+    while (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines.join('\n');
+}
+/**
+ * Serialize a cell buffer to a detailed format that includes style info.
+ * Format: each non-default cell shows [col,row char fg bg bold]
+ */
+export function bufferToStyledText(buffer) {
+    const lines = [];
+    for (let row = 0; row < buffer.height; row++) {
+        let chars = '';
+        const styles = [];
+        for (let col = 0; col < buffer.width; col++) {
+            const cell = buffer.getCell(col, row);
+            chars += cell.char;
+            if (hasStyle(cell)) {
+                const parts = [];
+                if (cell.fg !== 'default')
+                    parts.push(`fg:${cell.fg}`);
+                if (cell.bg !== 'default')
+                    parts.push(`bg:${cell.bg}`);
+                if (cell.bold)
+                    parts.push('bold');
+                if (cell.italic)
+                    parts.push('italic');
+                if (cell.underline)
+                    parts.push('underline');
+                if (cell.dim)
+                    parts.push('dim');
+                styles.push(`[${col}:${parts.join(',')}]`);
+            }
+        }
+        const trimmed = chars.trimEnd();
+        if (trimmed || styles.length > 0) {
+            const line = styles.length > 0
+                ? `${trimmed} ${styles.join(' ')}`
+                : trimmed;
+            lines.push(line);
+        }
+    }
+    // Trim trailing empty lines
+    while (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines.join('\n');
+}
+/**
+ * Render a cell buffer to SVG for visual inspection.
+ */
+export function bufferToSvg(buffer, options) {
+    const cw = options?.cellWidth ?? 10;
+    const ch = options?.cellHeight ?? 18;
+    const fontSize = Math.floor(ch * 0.75);
+    const width = buffer.width * cw;
+    const height = buffer.height * ch;
+    const parts = [];
+    parts.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" style="background:#1a1a2e">`);
+    parts.push(`<style>text { font-family: 'Menlo', 'Monaco', 'Courier New', monospace; font-size: ${fontSize}px; }</style>`);
+    for (let row = 0; row < buffer.height; row++) {
+        for (let col = 0; col < buffer.width; col++) {
+            const cell = buffer.getCell(col, row);
+            const x = col * cw;
+            const y = row * ch;
+            // Background
+            if (cell.bg !== 'default') {
+                const bgColor = colorToHex(cell.bg);
+                parts.push(`<rect x="${x}" y="${y}" width="${cw}" height="${ch}" fill="${bgColor}"/>`);
+            }
+            // Text
+            if (cell.char !== ' ') {
+                const fgColor = colorToHex(cell.fg === 'default' ? 'white' : cell.fg);
+                const weight = cell.bold ? 'font-weight="bold"' : '';
+                const decoration = cell.underline ? 'text-decoration="underline"' : '';
+                const fontStyle = cell.italic ? 'font-style="italic"' : '';
+                const textY = y + ch - Math.floor(ch * 0.25);
+                parts.push(`<text x="${x + 1}" y="${textY}" fill="${fgColor}" ${weight} ${decoration} ${fontStyle}>${escapeXml(cell.char)}</text>`);
+            }
+        }
+    }
+    parts.push('</svg>');
+    return parts.join('\n');
+}
+function hasStyle(cell) {
+    return cell.fg !== 'default' || cell.bg !== 'default'
+        || cell.bold || cell.italic || cell.underline
+        || cell.strikethrough || cell.dim;
+}
+function colorToHex(color) {
+    if (color.startsWith('#'))
+        return color;
+    const map = {
+        black: '#000000', red: '#ff0000', green: '#00ff00', yellow: '#ffff00',
+        blue: '#0000ff', magenta: '#ff00ff', cyan: '#00ffff', white: '#ffffff',
+        default: '#cccccc',
+    };
+    return map[color] ?? '#cccccc';
+}
+function escapeXml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}

package/dist/src/renderer/default.d.ts

@@ -0,0 +1,3 @@
+import { createTermRenderer } from './index.js';
+declare const renderer: ReturnType<typeof createTermRenderer>;
+export default renderer;

package/dist/src/renderer/default.js

@@ -0,0 +1,3 @@
+import { createTermRenderer } from './index.js';
+const renderer = createTermRenderer();
+export default renderer;

package/dist/src/renderer/index.d.ts

@@ -0,0 +1,11 @@
+import { createRenderer as svelteCreateRenderer } from 'svelte/renderer';
+import { TermNode } from './node.js';
+export declare function createTermRenderer(): ReturnType<typeof svelteCreateRenderer<TermNode, TermNode, TermNode, TermNode>>;
+/**
+ * Keep the custom renderer active globally so Svelte's effects
+ * use our renderer methods (setText, setAttribute, etc.) instead
+ * of falling back to DOM operations (node.nodeValue, etc.).
+ *
+ * Call this AFTER renderer.render() which pops the renderer.
+ */
+export { TermNode } from './node.js';