oakode 0.0.0-stage → 0.5.0

package/dist/tui/editor.js

@@ -0,0 +1,279 @@
+import { width } from "../ui.js";
+const PASTE_MARKER = /\[paste #(\d+)[^\]]*\]/g;
+const LONG_PASTE_LINES = 6;
+const LONG_PASTE_CHARS = 600;
+export class Editor {
+    buf = "";
+    cur = 0;
+    history = [];
+    multiline = true;
+    histIdx = -1;
+    draft = "";
+    pastes = new Map();
+    pasteSeq = 0;
+    typedBackslash = false;
+    /** The first character was typed (or recalled from history), not pasted: only then is a leading "!" a command. */
+    startTyped = false;
+    reset(text = "") {
+        this.startTyped = false;
+        this.buf = text;
+        this.cur = text.length;
+        this.histIdx = -1;
+        this.pastes.clear();
+        this.typedBackslash = false;
+    }
+    get empty() {
+        return this.buf === "";
+    }
+    beforeCursor() {
+        return this.buf.slice(0, this.cur);
+    }
+    /** The message to send: paste markers expanded to the pasted text. */
+    text() {
+        return this.buf.replace(PASTE_MARKER, (m, id) => this.pastes.get(Number(id)) ?? m);
+    }
+    remember(text) {
+        if (text.trim() && this.history.at(-1) !== text)
+            this.history.push(text);
+    }
+    /** Replace [from, cursor) with `text` (completion). */
+    replaceBeforeCursor(from, text) {
+        this.buf = this.buf.slice(0, from) + text + this.buf.slice(this.cur);
+        this.cur = from + text.length;
+    }
+    /** Apply a key. Returns "submit" when Enter should send the message, "edited" when the text or cursor changed. */
+    handle(key) {
+        const first = this.buf[0], atStart = this.cur === 0;
+        const r = this.apply(key);
+        if (key.k === "text" && atStart)
+            this.startTyped = true;
+        else if (key.k === "up" || key.k === "down")
+            this.startTyped = this.buf[0] !== first ? true : this.startTyped;
+        else if ((key.k === "paste" && atStart) || this.buf[0] !== first)
+            this.startTyped = false;
+        return r;
+    }
+    apply(key) {
+        const wasTypedBackslash = this.typedBackslash;
+        this.typedBackslash = false;
+        switch (key.k) {
+            case "text": {
+                const s = this.multiline ? key.s : key.s.replace(/\n/g, " ");
+                this.insert(s);
+                this.typedBackslash = s.endsWith("\\");
+                return "edited";
+            }
+            case "paste":
+                this.insertPaste(key.s);
+                return "edited";
+            case "newline":
+                if (this.multiline)
+                    this.insert("\n");
+                return "edited";
+            case "enter":
+                // A typed (never pasted) trailing backslash continues the message on the next line.
+                if (this.multiline && wasTypedBackslash && this.buf[this.cur - 1] === "\\") {
+                    this.buf = this.buf.slice(0, this.cur - 1) + "\n" + this.buf.slice(this.cur);
+                    return "edited";
+                }
+                return "submit";
+            case "backspace":
+                if (this.cur > 0)
+                    this.remove(this.prevIdx(this.cur), this.cur);
+                return "edited";
+            case "delete":
+                if (this.cur < this.buf.length)
+                    this.remove(this.cur, this.nextIdx(this.cur));
+                return "edited";
+            case "left":
+                this.cur = this.outOfMarker(this.prevIdx(this.cur), -1);
+                return "edited";
+            case "right":
+                this.cur = this.outOfMarker(this.nextIdx(this.cur), 1);
+                return "edited";
+            case "home":
+                this.cur = this.lineStart(this.cur);
+                return "edited";
+            case "end":
+                this.cur = this.lineEnd(this.cur);
+                return "edited";
+            case "wordleft":
+                this.cur = this.outOfMarker(this.wordLeft(this.cur), -1);
+                return "edited";
+            case "wordright":
+                this.cur = this.outOfMarker(this.wordRight(this.cur), 1);
+                return "edited";
+            case "delword":
+                this.remove(this.wordLeft(this.cur), this.cur);
+                return "edited";
+            case "up":
+                this.vertical(-1);
+                this.cur = this.outOfMarker(this.cur, 1);
+                return "edited";
+            case "down":
+                this.vertical(1);
+                this.cur = this.outOfMarker(this.cur, 1);
+                return "edited";
+            case "ctrl":
+                if (key.c === "a")
+                    this.cur = this.lineStart(this.cur);
+                else if (key.c === "e")
+                    this.cur = this.lineEnd(this.cur);
+                else if (key.c === "k")
+                    this.remove(this.cur, this.lineEnd(this.cur) === this.cur && this.cur < this.buf.length ? this.cur + 1 : this.lineEnd(this.cur));
+                else if (key.c === "u")
+                    this.remove(this.lineStart(this.cur), this.cur);
+                else if (key.c === "w")
+                    this.remove(this.wordLeft(this.cur), this.cur);
+                else
+                    return "none";
+                return "edited";
+            default: return "none";
+        }
+    }
+    /** True when Up/Down would move within the text (so completion menus should not steal them) */
+    get multiLine() {
+        return this.buf.includes("\n");
+    }
+    insert(s) {
+        this.buf = this.buf.slice(0, this.cur) + s + this.buf.slice(this.cur);
+        this.cur += s.length;
+    }
+    insertPaste(text) {
+        if (!this.multiline)
+            return this.insert(text.replace(/\n/g, " "));
+        const lines = text.split("\n").length;
+        if (lines >= LONG_PASTE_LINES || text.length >= LONG_PASTE_CHARS) {
+            const id = ++this.pasteSeq;
+            this.pastes.set(id, text);
+            this.insert(lines > 1 ? `[paste #${id} +${lines} lines]` : `[paste #${id} ${text.length} chars]`);
+        }
+        else
+            this.insert(text);
+    }
+    /** The [start, end) of every paste marker whose paste is still held. */
+    markers() {
+        return [...this.buf.matchAll(PASTE_MARKER)].filter((m) => this.pastes.has(Number(m[1]))).map((m) => [m.index, m.index + m[0].length]);
+    }
+    /**
+     * A paste marker is one unit: a deletion that touches it removes all of it (and its paste). Deleting part of it would
+     * leave text that no longer expands, and the paste would be lost without a word.
+     */
+    remove(from, to) {
+        for (const [s, e] of this.markers()) {
+            if (from < e && to > s) {
+                from = Math.min(from, s);
+                to = Math.max(to, e);
+            }
+        }
+        this.buf = this.buf.slice(0, from) + this.buf.slice(to);
+        this.cur = from;
+    }
+    /** The cursor never rests inside a marker: moving into one goes to its far side. */
+    outOfMarker(i, dir) {
+        const m = this.markers().find(([s, e]) => i > s && i < e);
+        return m ? (dir < 0 ? m[0] : m[1]) : i;
+    }
+    prevIdx(i) {
+        if (i <= 0)
+            return 0;
+        const lo = this.buf.charCodeAt(i - 1);
+        return lo >= 0xdc00 && lo <= 0xdfff && i >= 2 ? i - 2 : i - 1;
+    }
+    nextIdx(i) {
+        if (i >= this.buf.length)
+            return this.buf.length;
+        const hi = this.buf.charCodeAt(i);
+        return hi >= 0xd800 && hi <= 0xdbff ? Math.min(i + 2, this.buf.length) : i + 1;
+    }
+    lineStart(i) {
+        return this.buf.lastIndexOf("\n", i - 1) + 1;
+    }
+    lineEnd(i) {
+        const e = this.buf.indexOf("\n", i);
+        return e < 0 ? this.buf.length : e;
+    }
+    wordLeft(i) {
+        while (i > 0 && /\s/.test(this.buf[i - 1]))
+            i--;
+        while (i > 0 && !/\s/.test(this.buf[i - 1]))
+            i--;
+        return i;
+    }
+    wordRight(i) {
+        while (i < this.buf.length && /\s/.test(this.buf[i]))
+            i++;
+        while (i < this.buf.length && !/\s/.test(this.buf[i]))
+            i++;
+        return i;
+    }
+    /** Up/Down move between lines; at the first/last line they browse history. */
+    vertical(dir) {
+        const start = this.lineStart(this.cur);
+        const col = this.cur - start;
+        if (dir < 0 && start > 0) {
+            const ps = this.lineStart(start - 1);
+            this.cur = Math.min(ps + col, start - 1);
+        }
+        else if (dir > 0 && this.lineEnd(this.cur) < this.buf.length) {
+            const ns = this.lineEnd(this.cur) + 1;
+            this.cur = Math.min(ns + col, this.lineEnd(ns));
+        }
+        else
+            this.browse(dir);
+    }
+    browse(dir) {
+        if (!this.history.length)
+            return;
+        if (this.histIdx < 0) {
+            if (dir > 0)
+                return;
+            this.draft = this.buf;
+            this.histIdx = this.history.length;
+        }
+        this.histIdx += dir;
+        if (this.histIdx >= this.history.length) {
+            this.histIdx = -1;
+            this.buf = this.draft;
+        }
+        else
+            this.buf = this.history[Math.max(0, this.histIdx)];
+        this.cur = this.buf.length;
+    }
+    /** Visual rows for `cols` columns (display width aware: Hangul/CJK are two columns), with the cursor position. */
+    render(cols, prompt, promptWidth) {
+        const avail = Math.max(4, cols - promptWidth);
+        const rows = [];
+        let cursor = { row: 0, col: promptWidth };
+        let offset = 0;
+        this.buf.split("\n").forEach((line, li) => {
+            let cur = "";
+            let w = 0;
+            let rowStart = rows.length;
+            const startOfLine = offset;
+            const place = (idx) => {
+                if (this.cur === idx)
+                    cursor = { row: rows.length, col: promptWidth + w };
+            };
+            let idx = startOfLine;
+            for (const ch of line) {
+                const cw = width(ch);
+                place(idx);
+                if (w + cw > avail) {
+                    rows.push(cur);
+                    cur = "";
+                    w = 0;
+                    place(idx);
+                }
+                cur += ch;
+                w += cw;
+                idx += ch.length;
+            }
+            place(idx);
+            rows.push(cur);
+            void rowStart;
+            offset += line.length + 1;
+        });
+        return { lines: rows.map((r, i) => (i === 0 ? prompt : " ".repeat(promptWidth)) + r), cursor };
+    }
+}

package/dist/tui/highlight.js

@@ -0,0 +1,78 @@
+/** Syntax highlighting for fenced code: highlight.js (core + a fixed set of languages) converted to ANSI. */
+import hljs from "highlight.js/lib/core";
+import bash from "highlight.js/lib/languages/bash";
+import c from "highlight.js/lib/languages/c";
+import cpp from "highlight.js/lib/languages/cpp";
+import css from "highlight.js/lib/languages/css";
+import diff from "highlight.js/lib/languages/diff";
+import go from "highlight.js/lib/languages/go";
+import ini from "highlight.js/lib/languages/ini";
+import java from "highlight.js/lib/languages/java";
+import javascript from "highlight.js/lib/languages/javascript";
+import json from "highlight.js/lib/languages/json";
+import kotlin from "highlight.js/lib/languages/kotlin";
+import markdown from "highlight.js/lib/languages/markdown";
+import php from "highlight.js/lib/languages/php";
+import python from "highlight.js/lib/languages/python";
+import ruby from "highlight.js/lib/languages/ruby";
+import rust from "highlight.js/lib/languages/rust";
+import sql from "highlight.js/lib/languages/sql";
+import swift from "highlight.js/lib/languages/swift";
+import typescript from "highlight.js/lib/languages/typescript";
+import xml from "highlight.js/lib/languages/xml";
+import yaml from "highlight.js/lib/languages/yaml";
+import { colorEnabled } from "../ui.js";
+const langs = { bash, c, cpp, css, diff, go, ini, java, javascript, json, kotlin, markdown, php, python, ruby, rust, sql, swift, typescript, xml, yaml };
+for (const [name, def] of Object.entries(langs))
+    hljs.registerLanguage(name, def);
+const ALIASES = {
+    js: "javascript", jsx: "javascript", mjs: "javascript", cjs: "javascript", ts: "typescript", tsx: "typescript", sh: "bash", shell: "bash", zsh: "bash",
+    console: "bash", py: "python", yml: "yaml", html: "xml", svg: "xml", rs: "rust", rb: "ruby", md: "markdown", golang: "go", "c++": "cpp", cc: "cpp", h: "c",
+    kt: "kotlin", toml: "ini", jsonc: "json", json5: "json", patch: "diff",
+};
+// hljs class -> SGR (foreground only; works on dark and light backgrounds)
+const STYLE = [
+    [/keyword|selector-tag|doctag|operator-word/, "35"],
+    [/string|regexp|template-variable|addition/, "32"],
+    [/number|literal|symbol|bullet/, "33"],
+    [/comment|quote|meta/, "90;3"],
+    [/title|function|section/, "34"],
+    [/built_in|type|class|tag|name|selector-class|selector-id/, "36"],
+    [/attr|attribute|property|variable|params/, "36"],
+    [/deletion/, "31"],
+];
+const sgrFor = (cls) => STYLE.find(([re]) => re.test(cls))?.[1];
+const entities = (s) => s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+export function languageFor(info) {
+    const l = (info ?? "").trim().split(/\s+/)[0].toLowerCase();
+    const name = ALIASES[l] ?? l;
+    return hljs.getLanguage(name) ? name : undefined;
+}
+/** Highlighted lines of `code` (one string per line, each self-contained ANSI). Plain text when the language is unknown. */
+export function highlightLines(code, info) {
+    const lang = languageFor(info);
+    if (!lang || !colorEnabled)
+        return code.split("\n");
+    let html;
+    try {
+        html = hljs.highlight(code, { language: lang, ignoreIllegals: true }).value;
+    }
+    catch {
+        return code.split("\n");
+    }
+    const stack = [];
+    let out = "";
+    for (const m of html.matchAll(/<span class="([^"]*)">|<\/span>|([^<]+)/g)) {
+        if (m[1] !== undefined)
+            stack.push(m[1].split(/\s+/).map((c) => c.replace(/^hljs-/, "")).map(sgrFor).find(Boolean));
+        else if (m[2] === undefined)
+            stack.pop();
+        else {
+            const text = entities(m[2]);
+            const style = [...stack].reverse().find(Boolean);
+            // style each line separately so every returned line is self-contained
+            out += text.split("\n").map((l) => (style && l ? `\x1b[${style}m${l}\x1b[0m` : l)).join("\n");
+        }
+    }
+    return out.split("\n");
+}

package/dist/tui/markdown.js

@@ -0,0 +1,254 @@
+/**
+ * Markdown -> terminal lines. `renderMarkdown` renders a complete document; `MarkdownStream` renders a stream:
+ * blocks that are certainly finished are returned once for committing to scrollback, and only the unfinished last block
+ * is re-rendered (as "live" lines). Parsing uses `marked` with a CJK-friendly emphasis rule (so `**굵게**한글` works).
+ */
+import { Marked } from "marked";
+import markedCjkFriendly from "marked-cjk-friendly";
+import { bold, cyan, dim, gray, italic, padEnd, strike, underline, blue, width, wrap, yellow, green } from "../ui.js";
+import { highlightLines } from "./highlight.js";
+const marked = new Marked(markedCjkFriendly(), { gfm: true, breaks: false });
+const lex = (src) => marked.lexer(src);
+// ---------------------------------------------------------------- inline
+function inline(tokens) {
+    if (!tokens)
+        return "";
+    let out = "";
+    for (const t of tokens) {
+        switch (t.type) {
+            case "text":
+            case "escape":
+                out += "tokens" in t && t.tokens ? inline(t.tokens) : decode(t.text);
+                break;
+            case "strong":
+                out += bold(inline(t.tokens));
+                break;
+            case "em":
+                out += italic(inline(t.tokens));
+                break;
+            case "del":
+                out += strike(inline(t.tokens));
+                break;
+            case "codespan":
+                out += yellow(decode(t.text));
+                break;
+            case "br":
+                out += "\n";
+                break;
+            case "link": {
+                const l = t;
+                const text = inline(l.tokens);
+                const plain = decode(l.text);
+                out += l.href === plain || l.href === "mailto:" + plain ? underline(blue(text)) : `${underline(blue(text))} ${dim("(" + l.href + ")")}`;
+                break;
+            }
+            case "image":
+                out += dim(`[image: ${t.text || "image"}] ${t.href}`);
+                break;
+            case "html":
+                out += dim(t.text);
+                break;
+            default: out += "raw" in t ? String(t.raw) : "";
+        }
+    }
+    return out;
+}
+const decode = (s) => s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+// ---------------------------------------------------------------- blocks
+const bar = (s) => gray(s);
+function codeBlock(t, cols) {
+    const lang = (t.lang ?? "").trim().split(/\s+/)[0];
+    const body = highlightLines(t.text.replace(/\t/g, "  "), t.lang);
+    // no gutter and no wrapping: a copied block is the code as written (the terminal soft-wraps long lines)
+    return [bar("┌ ") + dim(lang || "code"), ...body, bar("└")];
+}
+function listBlock(t, cols, live) {
+    const out = [];
+    const start = typeof t.start === "number" ? t.start : 1;
+    t.items.forEach((item, i) => {
+        const marker = t.ordered ? `${start + i}.` : item.task ? (item.checked ? "☑" : "☐") : "•";
+        const lead = " " + marker + " ";
+        const pad = " ".repeat(width(lead));
+        const inner = blocks(item.tokens, Math.max(10, cols - width(lead)), live, true);
+        // an item's own paragraphs are kept tight (no blank line between a bullet and its text)
+        const lines = inner.length ? inner : [""];
+        lines.forEach((l, j) => out.push((j === 0 ? dim(lead) : pad) + l));
+    });
+    return out;
+}
+function tableBlock(t, cols) {
+    const rows = [t.header.map((c) => inline(c.tokens)), ...t.rows.map((r) => r.map((c) => inline(c.tokens)))];
+    const n = t.header.length;
+    const natural = Array.from({ length: n }, (_, c) => Math.max(3, ...rows.map((r) => Math.max(...(r[c] ?? "").split("\n").map(width)))));
+    const avail = cols - (3 * n + 1);
+    if (avail < 3 * n) {
+        // too narrow for a drawn table: one "header: value" block per row
+        const out = [];
+        rows.slice(1).forEach((r, i) => {
+            if (i)
+                out.push("");
+            r.forEach((cell, c) => out.push(...wrap(`${bold(rows[0][c])}: ${cell}`, cols)));
+        });
+        return out;
+    }
+    let w = [...natural];
+    if (natural.reduce((a, b) => a + b, 0) > avail) {
+        // shrink the widest columns first, never below 6 (or what fits)
+        const min = Math.max(3, Math.min(6, Math.floor(avail / n)));
+        let over = natural.reduce((a, b) => a + b, 0) - Math.max(avail, min * n);
+        while (over > 0) {
+            const i = w.indexOf(Math.max(...w));
+            if (w[i] <= min)
+                break;
+            w[i]--;
+            over--;
+        }
+    }
+    const line = (l, m, r) => bar(l + w.map((x) => "─".repeat(x + 2)).join(m) + r);
+    const row = (cells, head) => {
+        const wrapped = cells.map((c, i) => wrap(head ? bold(c) : c, w[i]));
+        const h = Math.max(...wrapped.map((x) => x.length));
+        const out = [];
+        for (let k = 0; k < h; k++) {
+            out.push(bar("│") +
+                wrapped
+                    .map((cell, i) => {
+                    const txt = cell[k] ?? "";
+                    const pad = " ".repeat(Math.max(0, w[i] - width(txt)));
+                    const al = t.align[i];
+                    return " " + (al === "right" ? pad + txt : al === "center" ? " ".repeat(Math.floor(pad.length / 2)) + txt + " ".repeat(Math.ceil(pad.length / 2)) : txt + pad) + " ";
+                })
+                    .join(bar("│")) +
+                bar("│"));
+        }
+        return out;
+    };
+    return [line("┌", "┬", "┐"), ...row(rows[0], true), line("├", "┼", "┤"), ...rows.slice(1).flatMap((r) => row(r, false)), line("└", "┴", "┘")];
+}
+function blocks(tokens, cols, live, inItem = false) {
+    const out = [];
+    let first = true;
+    const push = (lines, tight = false) => {
+        if (!lines.length)
+            return;
+        if (!first && !tight)
+            out.push("");
+        out.push(...lines);
+        first = false;
+    };
+    for (const t of tokens) {
+        switch (t.type) {
+            case "space":
+            case "checkbox": break; // the box is drawn from item.checked
+            case "heading": {
+                const h = t;
+                const text = inline(h.tokens);
+                push(wrap(h.depth === 1 ? bold(underline(cyan(text))) : h.depth === 2 ? bold(blue(text)) : bold(text), cols));
+                break;
+            }
+            case "paragraph":
+                push(wrap(inline(t.tokens), cols));
+                break;
+            case "text":
+                push(wrap(inline(t.tokens ?? [t]), cols), true);
+                break; // list-item text: tight
+            case "code":
+                push(codeBlock(t, cols));
+                break;
+            case "blockquote":
+                push(blocks(t.tokens, Math.max(10, cols - 2), live).map((l) => bar("▎ ") + italic(l)));
+                break;
+            case "list":
+                push(listBlock(t, cols, live), inItem);
+                break; // a list nested in an item stays tight
+            case "table":
+                push(live ? t.raw.trimEnd().split("\n").map((l) => dim(l)) : tableBlock(t, cols));
+                break;
+            case "hr":
+                push([dim("─".repeat(Math.min(cols, 80)))]);
+                break;
+            case "html":
+                push(t.text.trimEnd().split("\n").map((l) => dim(l)));
+                break;
+            default: push(wrap(String(t.raw ?? "").trimEnd(), cols));
+        }
+    }
+    return out;
+}
+/** A complete Markdown document as terminal lines hard-wrapped to `cols`. */
+export function renderMarkdown(src, cols) {
+    return blocks(lex(src), cols, false);
+}
+// ---------------------------------------------------------------- streaming
+/**
+ * Feed text deltas with `push`; call `pull` each frame. `commit` lines are final (print them once, above the live
+ * region); `live` lines are the unfinished block, re-rendered every frame. If the live block is taller than `maxRows`,
+ * its head is committed early when that is safe (code blocks), so the live region stays small.
+ */
+export class MarkdownStream {
+    buf = "";
+    consumed = 0; // characters of `buf` that belong to committed blocks
+    emitted = false; // any block committed (a blank line separates blocks)
+    skip = 0; // lines of the current live block already committed early
+    push(delta) {
+        this.buf += delta;
+    }
+    get text() {
+        return this.buf;
+    }
+    get empty() {
+        return this.buf.trim() === "";
+    }
+    render(tokens, cols, live) {
+        return blocks(tokens, cols, live);
+    }
+    pull(cols, maxRows) {
+        const rest = this.buf.slice(this.consumed);
+        const tokens = lex(rest);
+        let last = tokens.length - 1;
+        while (last >= 0 && tokens[last].type === "space")
+            last--;
+        const done = tokens.slice(0, Math.max(0, last));
+        const commit = [];
+        if (done.length) {
+            const lines = this.render(done, cols, false);
+            if (lines.length)
+                commit.push(...this.withGap(lines).slice(this.skip));
+            this.emitted = this.emitted || lines.length > 0;
+            this.consumed += done.map((t) => t.raw).join("").length;
+            this.skip = 0;
+        }
+        if (last < 0)
+            return { commit, live: [] };
+        let live = this.render([tokens[last]], cols, true);
+        if (live.length)
+            live = this.withGap(live).slice(this.skip);
+        if (live.length > maxRows) {
+            const extra = live.length - maxRows;
+            // Only a code block's head is final (its lines never change when more text arrives). For lists, quotes, tables and
+            // paragraphs later text can re-parse earlier lines (nesting, **spanning lines**), so show the tail and commit once.
+            if (tokens[last].type === "code") {
+                commit.push(...live.slice(0, extra));
+                this.skip += extra;
+            }
+            live = live.slice(extra);
+        }
+        return { commit, live };
+    }
+    /** A block after an earlier one starts with a blank line. `skip` counts lines already committed, that blank included. */
+    withGap(lines) {
+        return this.emitted ? ["", ...lines] : lines;
+    }
+    /** The end of the message: everything still pending, rendered as final. */
+    finish(cols) {
+        const tokens = lex(this.buf.slice(this.consumed));
+        const lines = this.render(tokens, cols, false);
+        const out = lines.length ? this.withGap(lines).slice(this.skip) : [];
+        this.buf = "";
+        this.consumed = 0;
+        this.emitted = false;
+        this.skip = 0;
+        return out;
+    }
+}
+export { padEnd, green };