@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/shell/parser.d.ts

@@ -0,0 +1,7 @@
+import { type Token, type ScriptNode } from './types.js';
+export declare class ParseError extends Error {
+    pos: number;
+    constructor(message: string, pos: number);
+}
+export declare function parse(tokens: Token[]): ScriptNode;
+//# sourceMappingURL=parser.d.ts.map

package/dist/substrate/lifo/shell/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/shell/parser.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,KAAK,EAEV,KAAK,UAAU,EAgBhB,MAAM,YAAY,CAAC;AAEpB,qBAAa,UAAW,SAAQ,KAAK;IACC,GAAG,EAAE,MAAM;gBAAnC,OAAO,EAAE,MAAM,EAAS,GAAG,EAAE,MAAM;CAIhD;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAGjD"}

package/dist/substrate/lifo/shell/parser.js

@@ -0,0 +1,573 @@
+import { lex } from './lexer.js';
+import { TokenKind, } from './types.js';
+export class ParseError extends Error {
+    pos;
+    constructor(message, pos) {
+        super(message);
+        this.pos = pos;
+        this.name = 'ParseError';
+    }
+}
+export function parse(tokens) {
+    const parser = new Parser(tokens);
+    return parser.parseScript();
+}
+function isUnquotedLiteralWord(token, value) {
+    if (token.kind !== TokenKind.Word || token.value !== value)
+        return false;
+    const parts = token.parts ?? [{ text: token.value, quoted: 'none' }];
+    return parts.length === 1
+        && parts[0]?.text === value
+        && parts[0]?.quoted === 'none'
+        && parts[0]?.commandSubstitution === undefined;
+}
+const KEYWORDS = new Set([
+    'if', 'then', 'else', 'elif', 'fi',
+    'for', 'in', 'do', 'done',
+    'while', 'until',
+    'case', 'esac',
+]);
+class Parser {
+    tokens;
+    pos = 0;
+    pendingHeredocs = [];
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    peek() {
+        return this.tokens[this.pos] ?? { kind: TokenKind.EOF, value: '', pos: -1 };
+    }
+    peekAt(offset) {
+        return this.tokens[this.pos + offset] ?? { kind: TokenKind.EOF, value: '', pos: -1 };
+    }
+    advance() {
+        const token = this.peek();
+        if (token.kind !== TokenKind.EOF) {
+            this.pos++;
+        }
+        return token;
+    }
+    expect(kind) {
+        const token = this.peek();
+        if (token.kind !== kind) {
+            throw new ParseError(`Expected ${TokenKind[kind]} but got ${TokenKind[token.kind]} ('${token.value}')`, token.pos);
+        }
+        return this.advance();
+    }
+    expectWord(value) {
+        const token = this.peek();
+        if (token.kind !== TokenKind.Word || token.value !== value) {
+            throw new ParseError(`Expected '${value}' but got '${token.value}'`, token.pos);
+        }
+        return this.advance();
+    }
+    isAtEnd() {
+        return this.peek().kind === TokenKind.EOF;
+    }
+    isWord(value) {
+        return this.peek().kind === TokenKind.Word && this.peek().value === value;
+    }
+    skipNewlines() {
+        while (this.peek().kind === TokenKind.Newline) {
+            this.advance();
+        }
+    }
+    parseScript() {
+        const lists = [];
+        // Skip leading separators
+        this.skipSeparators();
+        while (!this.isAtEnd()) {
+            const prevPos = this.pos;
+            lists.push(this.parseList());
+            this.consumeHeredocBodies();
+            this.skipSeparators();
+            // Guard against infinite loop: if no progress was made, the current token
+            // is unexpected (e.g. a stray '(' from pasted JS code). Throw so the
+            // caller can display an error instead of hanging the browser.
+            if (this.pos === prevPos) {
+                throw new ParseError(`unexpected token '${this.peek().value}'`, this.peek().pos);
+            }
+        }
+        return { type: 'script', lists };
+    }
+    skipSeparators() {
+        while (this.peek().kind === TokenKind.Semi || this.peek().kind === TokenKind.Newline) {
+            this.advance();
+        }
+    }
+    parseList() {
+        const entries = [];
+        let background = false;
+        // First pipeline
+        const firstPipeline = this.parsePipeline();
+        entries.push({ pipeline: firstPipeline, connector: null });
+        // Chained pipelines with && or ||
+        while (this.peek().kind === TokenKind.And || this.peek().kind === TokenKind.Or) {
+            const connectorToken = this.advance();
+            const connector = connectorToken.value;
+            // Update the previous entry's connector
+            entries[entries.length - 1].connector = connector;
+            this.skipNewlines();
+            const pipeline = this.parsePipeline();
+            entries.push({ pipeline, connector: null });
+        }
+        // Check for background &
+        if (this.peek().kind === TokenKind.Amp) {
+            this.advance();
+            background = true;
+        }
+        return { type: 'list', entries, background };
+    }
+    parsePipeline() {
+        let negated = false;
+        // Check for ! prefix
+        if (this.peek().kind === TokenKind.Word && this.peek().value === '!') {
+            negated = true;
+            this.advance();
+        }
+        const commands = [];
+        commands.push(this.parseCommand());
+        while (this.peek().kind === TokenKind.Pipe) {
+            this.advance();
+            this.skipNewlines();
+            commands.push(this.parseCommand());
+        }
+        return { type: 'pipeline', commands, negated };
+    }
+    parseCommand() {
+        const token = this.peek();
+        // Check for compound command keywords
+        if (token.kind === TokenKind.Word) {
+            if (isUnquotedLiteralWord(token, '[[')) {
+                return this.parseDoubleBracketCommand();
+            }
+            switch (token.value) {
+                case 'if': return this.parseIf();
+                case 'for': return this.parseFor();
+                case 'while': return this.parseWhile();
+                case 'until': return this.parseUntil();
+                case 'case': return this.parseCase();
+            }
+            // Check for function definition: name () { ... }
+            if (this.peekAt(1).kind === TokenKind.LParen && this.peekAt(2).kind === TokenKind.RParen) {
+                const name = token.value;
+                // Don't treat keywords as function names
+                if (!KEYWORDS.has(name)) {
+                    return this.parseFunctionDef();
+                }
+            }
+        }
+        // { ... } group
+        if (token.kind === TokenKind.Word && token.value === '{') {
+            return this.parseGroup();
+        }
+        if (token.kind === TokenKind.LParen) {
+            return this.parseSubshell();
+        }
+        return this.parseSimpleCommand();
+    }
+    parseDoubleBracketCommand() {
+        this.advance();
+        const words = [];
+        while (!this.isAtEnd()) {
+            const token = this.advance();
+            if (isUnquotedLiteralWord(token, ']]')) {
+                return {
+                    type: 'double_bracket',
+                    words,
+                    redirections: this.parseTrailingRedirections(),
+                };
+            }
+            words.push(this.doubleBracketTokenParts(token));
+        }
+        throw new ParseError('missing ]]', this.peek().pos);
+    }
+    doubleBracketTokenParts(token) {
+        if (token.kind === TokenKind.Word) {
+            return token.parts ?? [{ text: token.value, quoted: 'none' }];
+        }
+        return [{ text: token.value, quoted: 'none' }];
+    }
+    parseCompoundList(terminators) {
+        const lists = [];
+        this.skipSeparators();
+        while (!this.isAtEnd()) {
+            const prevPos = this.pos;
+            // Check terminators
+            const t = this.peek();
+            if (t.kind === TokenKind.Word && terminators.includes(t.value)) {
+                break;
+            }
+            if (t.kind === TokenKind.RParen && terminators.includes(')')) {
+                break;
+            }
+            if (t.kind === TokenKind.EOF)
+                break;
+            lists.push(this.parseList());
+            this.consumeHeredocBodies();
+            this.skipSeparators();
+            if (this.pos === prevPos) {
+                throw new ParseError(`unexpected token '${this.peek().value}'`, this.peek().pos);
+            }
+        }
+        return lists;
+    }
+    parseIf() {
+        this.expectWord('if');
+        const clauses = [];
+        let elseBody = null;
+        // Parse first if clause
+        const condition = this.parseCompoundList(['then']);
+        this.expectWord('then');
+        const body = this.parseCompoundList(['elif', 'else', 'fi']);
+        clauses.push({ condition, body });
+        // Parse elif clauses
+        while (this.isWord('elif')) {
+            this.advance();
+            const elifCondition = this.parseCompoundList(['then']);
+            this.expectWord('then');
+            const elifBody = this.parseCompoundList(['elif', 'else', 'fi']);
+            clauses.push({ condition: elifCondition, body: elifBody });
+        }
+        // Parse else clause
+        if (this.isWord('else')) {
+            this.advance();
+            elseBody = this.parseCompoundList(['fi']);
+        }
+        this.expectWord('fi');
+        const redirections = this.parseTrailingRedirections();
+        return { type: 'if', clauses, elseBody, redirections };
+    }
+    parseFor() {
+        this.expectWord('for');
+        const varToken = this.expect(TokenKind.Word);
+        const variable = varToken.value;
+        this.skipNewlines();
+        let words = null;
+        // Optional 'in word...'
+        if (this.isWord('in')) {
+            this.advance();
+            words = [];
+            while (!this.isAtEnd()) {
+                const t = this.peek();
+                if (t.kind === TokenKind.Semi || t.kind === TokenKind.Newline)
+                    break;
+                if (t.kind === TokenKind.Word && t.value === 'do')
+                    break;
+                if (t.kind !== TokenKind.Word)
+                    break;
+                this.advance();
+                words.push(t.parts ?? [{ text: t.value, quoted: 'none' }]);
+            }
+        }
+        // Consume separator before 'do'
+        this.skipSeparators();
+        this.expectWord('do');
+        const body = this.parseCompoundList(['done']);
+        this.expectWord('done');
+        const redirections = this.parseTrailingRedirections();
+        return { type: 'for', variable, words, body, redirections };
+    }
+    parseWhile() {
+        this.expectWord('while');
+        const condition = this.parseCompoundList(['do']);
+        this.expectWord('do');
+        const body = this.parseCompoundList(['done']);
+        this.expectWord('done');
+        const redirections = this.parseTrailingRedirections();
+        return { type: 'while', condition, body, redirections };
+    }
+    parseUntil() {
+        this.expectWord('until');
+        const condition = this.parseCompoundList(['do']);
+        this.expectWord('do');
+        const body = this.parseCompoundList(['done']);
+        this.expectWord('done');
+        const redirections = this.parseTrailingRedirections();
+        return { type: 'until', condition, body, redirections };
+    }
+    parseCase() {
+        this.expectWord('case');
+        const wordToken = this.expect(TokenKind.Word);
+        const word = wordToken.parts ?? [{ text: wordToken.value, quoted: 'none' }];
+        this.skipNewlines();
+        this.expectWord('in');
+        this.skipSeparators();
+        const items = [];
+        while (!this.isAtEnd() && !this.isWord('esac')) {
+            // Optional leading (
+            if (this.peek().kind === TokenKind.LParen) {
+                this.advance();
+            }
+            // Parse patterns separated by |
+            const patterns = [];
+            const patToken = this.expect(TokenKind.Word);
+            patterns.push(patToken.parts ?? [{ text: patToken.value, quoted: 'none' }]);
+            while (this.peek().kind === TokenKind.Pipe) {
+                this.advance();
+                const nextPat = this.expect(TokenKind.Word);
+                patterns.push(nextPat.parts ?? [{ text: nextPat.value, quoted: 'none' }]);
+            }
+            // Expect )
+            this.expect(TokenKind.RParen);
+            // Parse body until ;; or esac
+            const body = [];
+            this.skipNewlines();
+            while (!this.isAtEnd()) {
+                const prevPos = this.pos;
+                const t = this.peek();
+                if (t.kind === TokenKind.DoubleSemi)
+                    break;
+                if (t.kind === TokenKind.Word && t.value === 'esac')
+                    break;
+                if (t.kind === TokenKind.EOF)
+                    break;
+                body.push(this.parseList());
+                this.skipSeparators();
+                if (this.pos === prevPos) {
+                    throw new ParseError(`unexpected token '${this.peek().value}'`, this.peek().pos);
+                }
+            }
+            items.push({ patterns, body });
+            // Consume ;;
+            if (this.peek().kind === TokenKind.DoubleSemi) {
+                this.advance();
+                this.skipSeparators();
+            }
+        }
+        this.expectWord('esac');
+        const redirections = this.parseTrailingRedirections();
+        return { type: 'case', word, items, redirections };
+    }
+    parseFunctionDef() {
+        const nameToken = this.advance(); // consume name
+        const name = nameToken.value;
+        this.expect(TokenKind.LParen);
+        this.expect(TokenKind.RParen);
+        this.skipNewlines();
+        const body = this.parseCommand();
+        return { type: 'function_def', name, body };
+    }
+    parseGroup() {
+        this.expectWord('{');
+        const body = this.parseCompoundList(['}']);
+        this.expectWord('}');
+        const redirections = this.parseTrailingRedirections();
+        return { type: 'group', body, redirections };
+    }
+    parseSubshell() {
+        this.expect(TokenKind.LParen);
+        const body = this.parseCompoundList([')']);
+        this.expect(TokenKind.RParen);
+        const redirections = this.parseTrailingRedirections();
+        return { type: 'subshell', body, redirections };
+    }
+    parseTrailingRedirections() {
+        const redirections = [];
+        while (this.isRedirectOperator(this.peek().kind)) {
+            redirections.push(this.parseRedirection());
+        }
+        return redirections;
+    }
+    parseSimpleCommand() {
+        const assignments = [];
+        const words = [];
+        const redirections = [];
+        while (!this.isAtEnd()) {
+            const token = this.peek();
+            // Check for redirections
+            if (this.isRedirectOperator(token.kind)) {
+                redirections.push(this.parseRedirection());
+                continue;
+            }
+            // Check for word tokens
+            if (token.kind === TokenKind.Word) {
+                // Don't consume keywords that are terminators in compound commands
+                // (only when no words have been accumulated yet -- empty command)
+                // This check is not needed here since parseCommand dispatches before us
+                // Check for VAR=value assignment (only before any regular words)
+                if (words.length === 0) {
+                    const assignment = parseAssignment(token);
+                    if (assignment !== null) {
+                        this.advance();
+                        assignments.push(assignment);
+                        continue;
+                    }
+                }
+                this.advance();
+                const parts = token.parts ?? [{ text: token.value, quoted: 'none' }];
+                words.push(parts);
+                continue;
+            }
+            // Anything else (operator) ends this command
+            break;
+        }
+        return { type: 'simple_command', assignments, words, redirections };
+    }
+    parseRedirection() {
+        const operatorToken = this.advance();
+        if (operatorToken.kind === TokenKind.Heredoc || operatorToken.kind === TokenKind.HeredocStripTabs) {
+            return this.parseHeredocRedirection(operatorToken, operatorToken.kind === TokenKind.HeredocStripTabs);
+        }
+        let operator = this.redirectionOperator(operatorToken.kind);
+        const fd = operatorToken.fd ?? this.defaultRedirectionFd(operatorToken.kind);
+        if (this.peek().kind === TokenKind.Amp) {
+            this.advance();
+            switch (operator) {
+                case 'write':
+                    operator = 'dupOutput';
+                    break;
+                case 'read':
+                    operator = 'dupInput';
+                    break;
+                default:
+                    throw new ParseError(`Unexpected file descriptor duplication after '${operatorToken.value}'`, operatorToken.pos);
+            }
+        }
+        const targetToken = this.expect(TokenKind.Word);
+        return {
+            operator,
+            fd,
+            target: targetToken.parts ?? [{ text: targetToken.value, quoted: 'none' }],
+        };
+    }
+    parseHeredocRedirection(operatorToken, stripTabs) {
+        const targetToken = this.expect(TokenKind.Word);
+        const redirection = {
+            operator: 'heredoc',
+            fd: operatorToken.fd ?? 0,
+            target: targetToken.parts ?? [{ text: targetToken.value, quoted: 'none' }],
+            heredoc: {
+                body: '',
+                quoted: false,
+                stripTabs,
+            },
+        };
+        this.pendingHeredocs.push(redirection);
+        return redirection;
+    }
+    consumeHeredocBodies() {
+        if (this.pendingHeredocs.length === 0)
+            return;
+        while (this.peek().kind === TokenKind.Newline)
+            this.advance();
+        while (this.pendingHeredocs.length > 0) {
+            const target = this.pendingHeredocs.shift();
+            if (!target)
+                break;
+            const bodyToken = this.expect(TokenKind.HeredocBody);
+            target.heredoc = {
+                body: bodyToken.value,
+                quoted: bodyToken.heredocQuoted ?? false,
+                stripTabs: target.heredoc?.stripTabs ?? false,
+            };
+        }
+    }
+    redirectionOperator(kind) {
+        switch (kind) {
+            case TokenKind.Heredoc:
+            case TokenKind.HeredocStripTabs:
+                return 'heredoc';
+            case TokenKind.RedirectOut:
+            case TokenKind.RedirectErr:
+                return 'write';
+            case TokenKind.RedirectAppend:
+            case TokenKind.RedirectErrAppend:
+                return 'append';
+            case TokenKind.RedirectIn:
+                return 'read';
+            case TokenKind.RedirectReadWrite:
+                return 'readWrite';
+            case TokenKind.RedirectAll:
+                return 'writeAll';
+            default:
+                throw new ParseError(`Expected redirection but got ${TokenKind[kind]}`, this.peek().pos);
+        }
+    }
+    defaultRedirectionFd(kind) {
+        switch (kind) {
+            case TokenKind.RedirectErr:
+            case TokenKind.RedirectErrAppend:
+                return 2;
+            case TokenKind.RedirectIn:
+            case TokenKind.Heredoc:
+            case TokenKind.HeredocStripTabs:
+            case TokenKind.RedirectReadWrite:
+                return 0;
+            case TokenKind.RedirectOut:
+            case TokenKind.RedirectAppend:
+                return 1;
+            case TokenKind.RedirectAll:
+                return null;
+            default:
+                throw new ParseError(`Expected redirection but got ${TokenKind[kind]}`, this.peek().pos);
+        }
+    }
+    isRedirectOperator(kind) {
+        return kind === TokenKind.RedirectOut
+            || kind === TokenKind.RedirectAppend
+            || kind === TokenKind.RedirectIn
+            || kind === TokenKind.RedirectReadWrite
+            || kind === TokenKind.Heredoc
+            || kind === TokenKind.HeredocStripTabs
+            || kind === TokenKind.RedirectErr
+            || kind === TokenKind.RedirectErrAppend
+            || kind === TokenKind.RedirectAll;
+    }
+}
+/**
+ * `NAME=value`, `NAME+=value`, `NAME[expr]=value` and `NAME=(word …)`.
+ *
+ * The lexer keeps a parenthesised list attached to its assignment, so an array
+ * assignment arrives as one word and is recognised here by its shape. Returns
+ * null for anything that is an ordinary word rather than an assignment.
+ */
+function parseAssignment(token) {
+    const head = /^([a-zA-Z_][a-zA-Z0-9_]*)(\[[^\]]*\])?(\+)?=/.exec(token.value);
+    if (head === null)
+        return null;
+    const [matched, name, bracket, plus] = head;
+    const value = partsAfter(token, matched.length);
+    const assignment = { name, value };
+    if (bracket !== undefined)
+        assignment.subscript = bracket.slice(1, -1);
+    if (plus !== undefined)
+        assignment.append = true;
+    const elements = parseArrayLiteral(token.value.slice(matched.length));
+    if (elements !== null) {
+        assignment.elements = elements;
+        assignment.value = [];
+    }
+    return assignment;
+}
+/** `(word …)` — the words inside are lexed and expanded like any argument. */
+function parseArrayLiteral(text) {
+    if (!text.startsWith('(') || !text.endsWith(')'))
+        return null;
+    const elements = [];
+    for (const token of lex(text.slice(1, -1))) {
+        if (token.kind !== TokenKind.Word)
+            continue;
+        elements.push(token.parts ?? [{ text: token.value, quoted: 'none' }]);
+    }
+    return elements;
+}
+/** The word parts that fall after `offset` characters of a token's text. */
+function partsAfter(token, offset) {
+    if (!token.parts)
+        return [{ text: token.value.slice(offset), quoted: 'none' }];
+    const parts = [];
+    let consumed = 0;
+    for (const part of token.parts) {
+        const end = consumed + part.text.length;
+        if (end <= offset) {
+            consumed = end;
+            continue;
+        }
+        parts.push(consumed < offset ? { ...part, text: part.text.slice(offset - consumed) } : part);
+        consumed = end;
+    }
+    if (parts.length === 0)
+        parts.push({ text: '', quoted: 'none' });
+    return parts;
+}

package/dist/substrate/lifo/shell/pipe.d.ts

@@ -0,0 +1,15 @@
+import type { CommandOutputStream, CommandInputStream } from '../commands/types.js';
+export declare class PipeChannel {
+    private buffer;
+    private closed;
+    private waiting;
+    readonly writer: CommandOutputStream;
+    readonly reader: CommandInputStream;
+    private read;
+    private readAll;
+    private readLine;
+    private readBytes;
+    close(): void;
+    private deliver;
+}
+//# sourceMappingURL=pipe.d.ts.map

package/dist/substrate/lifo/shell/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/shell/pipe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAEpF,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAA6C;IAE5D,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAKlC;IAEF,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAKjC;IAEF,OAAO,CAAC,IAAI;YAYE,OAAO;YAUP,QAAQ;YAiBR,SAAS;IAWvB,KAAK,IAAI,IAAI;IAQb,OAAO,CAAC,OAAO;CAYhB"}

package/dist/substrate/lifo/shell/pipe.js

@@ -0,0 +1,86 @@
+export class PipeChannel {
+    buffer = [];
+    closed = false;
+    waiting = [];
+    writer = {
+        write: (text) => {
+            if (this.closed)
+                return;
+            this.deliver(text, 'back');
+        },
+    };
+    reader = {
+        read: () => this.read(),
+        readAll: () => this.readAll(),
+        readLine: () => this.readLine(),
+        readBytes: (maxLength) => this.readBytes(maxLength),
+    };
+    read() {
+        if (this.buffer.length > 0) {
+            return Promise.resolve(this.buffer.shift() ?? null);
+        }
+        if (this.closed) {
+            return Promise.resolve(null);
+        }
+        return new Promise((resolve) => {
+            this.waiting.push(resolve);
+        });
+    }
+    async readAll() {
+        const parts = [];
+        while (true) {
+            const chunk = await this.read();
+            if (chunk === null)
+                break;
+            parts.push(chunk);
+        }
+        return parts.join('');
+    }
+    async readLine() {
+        let line = '';
+        while (true) {
+            const chunk = await this.read();
+            if (chunk === null)
+                return line.length > 0 ? line : null;
+            const newline = chunk.indexOf('\n');
+            if (newline >= 0) {
+                const rest = chunk.slice(newline + 1);
+                if (rest.length > 0)
+                    this.deliver(rest, 'front');
+                return line + chunk.slice(0, newline);
+            }
+            line += chunk;
+        }
+    }
+    async readBytes(maxLength) {
+        if (maxLength <= 0)
+            return '';
+        const chunk = await this.read();
+        if (chunk === null)
+            return null;
+        if (chunk.length <= maxLength)
+            return chunk;
+        this.deliver(chunk.slice(maxLength), 'front');
+        return chunk.slice(0, maxLength);
+    }
+    close() {
+        this.closed = true;
+        while (this.waiting.length > 0) {
+            const resolve = this.waiting.shift();
+            resolve(null);
+        }
+    }
+    deliver(text, position) {
+        if (text.length === 0)
+            return;
+        if (this.waiting.length > 0) {
+            const resolve = this.waiting.shift();
+            resolve(text);
+            return;
+        }
+        if (position === 'front')
+            this.buffer.unshift(text);
+        else
+            this.buffer.push(text);
+    }
+}