lognal 0.1.0

package/dist/sources/text/encoding.js

@@ -0,0 +1,59 @@
+/**
+ * The legacy encoding a browser assumes for a page in each language, used when a file is not
+ * valid UTF-8. The list is the "suggested default encoding" table of the HTML Standard.
+ */
+const LEGACY_ENCODINGS = [
+    [/^ko\b/i, 'euc-kr'],
+    [/^ja\b/i, 'shift_jis'],
+    [/^zh-(hant|hk|mo|tw)\b/i, 'big5'],
+    [/^zh\b/i, 'gbk'],
+    [/^(ba|be|bg|kk|ky|mk|ru|sah|sr|tg|tt|uk)\b/i, 'windows-1251'],
+    [/^(cs|hr|sk)\b/i, 'windows-1250'],
+    [/^(hu|pl|sl)\b/i, 'iso-8859-2'],
+    [/^el\b/i, 'iso-8859-7'],
+    [/^(et|lt|lv)\b/i, 'windows-1257'],
+    [/^(ar|fa)\b/i, 'windows-1256'],
+    [/^he\b/i, 'windows-1255'],
+    [/^(az|ku|tr)\b/i, 'windows-1254'],
+    [/^th\b/i, 'windows-874'],
+    [/^vi\b/i, 'windows-1258']
+];
+/** Returns the legacy encoding for a language tag, such as `euc-kr` for `ko-KR`. */
+export const legacyEncodingFor = (locale) => {
+    for (const [pattern, encoding] of LEGACY_ENCODINGS) {
+        if (locale && pattern.test(locale)) {
+            return encoding;
+        }
+    }
+    return 'windows-1252';
+};
+/** Returns the encoding a byte order mark at the start of the bytes announces, if any. */
+export const encodingFromBom = (bytes) => {
+    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        return 'utf-8';
+    }
+    if (bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return 'utf-16le';
+    }
+    if (bytes[0] === 0xfe && bytes[1] === 0xff) {
+        return 'utf-16be';
+    }
+    return null;
+};
+/** Returns whether the bytes are valid UTF-8. A sequence cut at the end still counts as valid. */
+export const isValidUtf8 = (bytes) => {
+    try {
+        new TextDecoder('utf-8', { fatal: true }).decode(bytes, { stream: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Picks the encoding of a file from its first bytes: the byte order mark if there is one,
+ * then UTF-8 if the bytes are valid UTF-8, and otherwise `fallback`.
+ */
+export const detectEncoding = (bytes, fallback) => {
+    return encodingFromBom(bytes) ?? (isValidUtf8(bytes) ? 'utf-8' : fallback);
+};

package/dist/sources/text/follow-file.d.ts

@@ -0,0 +1,49 @@
+import type { LogStore } from '../../core/store.js';
+import type { LogLevel } from '../../core/types.js';
+/** The part of `FileSystemFileHandle` that following a file needs. */
+export interface FileHandleLike {
+    getFile(): Promise<Blob & {
+        lastModified?: number;
+    }>;
+}
+export interface FollowTextOptions {
+    /** Milliseconds between checks for new data. */
+    interval?: number;
+    /** The encoding, or `auto` to detect it from the first bytes. */
+    encoding?: string;
+    /** The encoding `auto` falls back to when the file is not UTF-8. */
+    fallbackEncoding?: string;
+    /** The level of every line. */
+    level?: LogLevel;
+    /** Whether ANSI escape codes become styles. Defaults to `true`. */
+    ansi?: boolean;
+    /**
+     * Called when the file was replaced rather than appended to: it got shorter, or it kept its
+     * size but was modified. The file is then read again from the start.
+     */
+    onReset?: () => void;
+    /** Called when reading fails, for example because permission was withdrawn. */
+    onError?: (error: unknown) => void;
+}
+/** Controls a followed file. */
+export interface FollowHandle {
+    /** Stops checking the file and writes any unfinished last line. */
+    stop(): void;
+    /**
+     * Resolves after the first read with the number of lines it added, or rejects when the first
+     * read fails. Checking goes on either way; later failures go to `onError`.
+     */
+    ready: Promise<number>;
+}
+/**
+ * Reads a file and keeps adding the lines appended to it, like `tail -f`.
+ *
+ * This needs a file handle from the File System Access API (`showOpenFilePicker`), which only
+ * Chromium-based browsers provide. Every check asks the handle for a fresh copy of the file
+ * and reads what was added since the last one. A file picked with `<input type="file">` is a
+ * snapshot that cannot be followed; read it once with `readTextFile` instead.
+ *
+ * When the file gets shorter, or keeps its size but changes, it was replaced rather than
+ * appended to, so it is read again from the start and `onReset` is called.
+ */
+export declare const followTextFile: (handle: FileHandleLike, store: LogStore, options?: FollowTextOptions) => FollowHandle;

package/dist/sources/text/follow-file.js

@@ -0,0 +1,109 @@
+import { detectEncoding, legacyEncodingFor } from './encoding.js';
+import { TextLineWriter } from './read-file.js';
+const DEFAULT_INTERVAL = 1000;
+const browserLanguage = () => {
+    return globalThis.navigator?.language;
+};
+/**
+ * Reads a file and keeps adding the lines appended to it, like `tail -f`.
+ *
+ * This needs a file handle from the File System Access API (`showOpenFilePicker`), which only
+ * Chromium-based browsers provide. Every check asks the handle for a fresh copy of the file
+ * and reads what was added since the last one. A file picked with `<input type="file">` is a
+ * snapshot that cannot be followed; read it once with `readTextFile` instead.
+ *
+ * When the file gets shorter, or keeps its size but changes, it was replaced rather than
+ * appended to, so it is read again from the start and `onReset` is called.
+ */
+export const followTextFile = (handle, store, options = {}) => {
+    const interval = options.interval ?? DEFAULT_INTERVAL;
+    const writerOptions = { level: options.level, ansi: options.ansi };
+    let writer = new TextLineWriter(store, writerOptions);
+    let decoder = null;
+    let offset = 0;
+    let lastModified;
+    let stopped = false;
+    let timer;
+    let settleReady = null;
+    const ready = new Promise((resolve, reject) => {
+        settleReady = { resolve, reject };
+    });
+    // A caller that never awaits `ready` should not see an unhandled rejection.
+    ready.catch(() => undefined);
+    const reset = () => {
+        writer.write(decoder?.decode() ?? '');
+        writer.flush();
+        writer = new TextLineWriter(store, writerOptions);
+        decoder = null;
+        offset = 0;
+        options.onReset?.();
+    };
+    const check = async () => {
+        const file = await handle.getFile();
+        if (stopped) {
+            return;
+        }
+        const replaced = file.size < offset ||
+            (file.size === offset &&
+                offset > 0 &&
+                file.lastModified !== undefined &&
+                lastModified !== undefined &&
+                file.lastModified !== lastModified);
+        lastModified = file.lastModified;
+        if (replaced) {
+            reset();
+        }
+        if (file.size === offset) {
+            return;
+        }
+        const bytes = new Uint8Array(await file.slice(offset).arrayBuffer());
+        if (stopped) {
+            return;
+        }
+        if (!decoder) {
+            const requested = options.encoding ?? 'auto';
+            const encoding = requested === 'auto'
+                ? detectEncoding(bytes, options.fallbackEncoding ?? legacyEncodingFor(browserLanguage()))
+                : requested;
+            decoder = new TextDecoder(encoding);
+        }
+        writer.write(decoder.decode(bytes, { stream: true }));
+        offset += bytes.byteLength;
+    };
+    const loop = async () => {
+        if (stopped) {
+            return;
+        }
+        try {
+            await check();
+            settleReady?.resolve(writer.lines);
+        }
+        catch (error) {
+            if (settleReady) {
+                settleReady.reject(error);
+            }
+            else {
+                options.onError?.(error);
+            }
+        }
+        settleReady = null;
+        if (!stopped) {
+            timer = setTimeout(() => {
+                void loop();
+            }, interval);
+        }
+    };
+    void loop();
+    return {
+        ready,
+        stop: () => {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            clearTimeout(timer);
+            writer.write(decoder?.decode() ?? '');
+            writer.flush();
+        }
+    };
+};

package/dist/sources/text/read-file.d.ts

@@ -0,0 +1,63 @@
+import type { LogStore } from '../../core/store.js';
+import type { LogLevel } from '../../core/types.js';
+export interface ReadTextOptions {
+    /**
+     * The encoding of the file, such as `utf-8` or `euc-kr`. `auto` reads the byte order mark,
+     * then tries UTF-8, then falls back to `fallbackEncoding`.
+     */
+    encoding?: string;
+    /**
+     * The encoding used by `auto` when the file is not UTF-8. Defaults to the legacy encoding of
+     * the browser language, such as `euc-kr` for Korean.
+     */
+    fallbackEncoding?: string;
+    /** The level of every line. */
+    level?: LogLevel;
+    /** Whether ANSI escape codes become styles. Defaults to `true`. */
+    ansi?: boolean;
+    /** Bytes read at a time. */
+    chunkSize?: number;
+    /** Stops reading when aborted. The lines read so far stay in the store. */
+    signal?: AbortSignal;
+    /** Called after every chunk with the bytes read so far and the total size. */
+    onProgress?: (loaded: number, total: number) => void;
+}
+export interface ReadTextResult {
+    /** The number of lines added. */
+    lines: number;
+    /** The number of bytes read. */
+    bytes: number;
+    /** The encoding used. */
+    encoding: string;
+}
+/**
+ * Turns decoded text into store entries one line at a time, keeping partial lines and the ANSI
+ * style between chunks.
+ */
+export declare class TextLineWriter {
+    private readonly store;
+    private readonly options;
+    private readonly splitter;
+    private readonly parser;
+    private count;
+    constructor(store: LogStore, options?: {
+        level?: LogLevel;
+        ansi?: boolean;
+    });
+    /** The number of lines written. */
+    get lines(): number;
+    /** Whether an unfinished line is waiting for its line break. */
+    get hasPending(): boolean;
+    write(text: string): void;
+    /** Writes the unfinished last line, if any. */
+    flush(): void;
+    private add;
+}
+/**
+ * Reads a text file, such as one picked with `<input type="file">` or dropped on the page, and
+ * adds one entry per line.
+ *
+ * The file is read in chunks, so a large file does not have to fit in memory as one string.
+ * The store's `maxEntries` still decides how many lines are kept.
+ */
+export declare const readTextFile: (file: Blob, store: LogStore, options?: ReadTextOptions) => Promise<ReadTextResult>;

package/dist/sources/text/read-file.js

@@ -0,0 +1,82 @@
+import { AnsiParser } from '../../core/text/ansi.js';
+import { LineSplitter } from '../../core/text/line-splitter.js';
+import { detectEncoding, legacyEncodingFor } from './encoding.js';
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
+const DETECTION_BYTES = 64 * 1024;
+const browserLanguage = () => {
+    return globalThis.navigator?.language;
+};
+/**
+ * Turns decoded text into store entries one line at a time, keeping partial lines and the ANSI
+ * style between chunks.
+ */
+export class TextLineWriter {
+    store;
+    options;
+    splitter = new LineSplitter();
+    parser;
+    count = 0;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.options = options;
+        this.parser = options.ansi === false ? null : new AnsiParser();
+    }
+    /** The number of lines written. */
+    get lines() {
+        return this.count;
+    }
+    /** Whether an unfinished line is waiting for its line break. */
+    get hasPending() {
+        return this.splitter.hasPending;
+    }
+    write(text) {
+        this.add(this.splitter.push(text));
+    }
+    /** Writes the unfinished last line, if any. */
+    flush() {
+        this.add(this.splitter.flush());
+    }
+    add(lines) {
+        if (lines.length === 0) {
+            return;
+        }
+        const level = this.options.level ?? 'log';
+        const entries = lines.map((line) => ({
+            level,
+            parts: this.parser ? this.parser.parse(line) : [{ type: 'text', text: line }]
+        }));
+        this.store.append(entries);
+        this.count += lines.length;
+    }
+}
+/**
+ * Reads a text file, such as one picked with `<input type="file">` or dropped on the page, and
+ * adds one entry per line.
+ *
+ * The file is read in chunks, so a large file does not have to fit in memory as one string.
+ * The store's `maxEntries` still decides how many lines are kept.
+ */
+export const readTextFile = async (file, store, options = {}) => {
+    const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
+    const head = new Uint8Array(await file.slice(0, DETECTION_BYTES).arrayBuffer());
+    const requested = options.encoding ?? 'auto';
+    const encoding = requested === 'auto'
+        ? detectEncoding(head, options.fallbackEncoding ?? legacyEncodingFor(browserLanguage()))
+        : requested;
+    const decoder = new TextDecoder(encoding);
+    const writer = new TextLineWriter(store, { level: options.level, ansi: options.ansi });
+    let offset = 0;
+    while (offset < file.size) {
+        if (options.signal?.aborted) {
+            break;
+        }
+        const end = Math.min(file.size, offset + chunkSize);
+        const bytes = new Uint8Array(await file.slice(offset, end).arrayBuffer());
+        writer.write(decoder.decode(bytes, { stream: true }));
+        offset = end;
+        options.onProgress?.(offset, file.size);
+    }
+    writer.write(decoder.decode());
+    writer.flush();
+    return { lines: writer.lines, bytes: offset, encoding };
+};

package/dist/viewer/icons.d.ts

@@ -0,0 +1,14 @@
+/** Path data for the toolbar icons, drawn on a 16 by 16 grid with a 1.5 stroke. */
+declare const ICON_PATHS: {
+    readonly follow: "M8 2.75v7.5M4.75 7 8 10.25 11.25 7M3.5 13.25h9";
+    readonly clear: "M8 2.75a5.25 5.25 0 1 0 0 10.5 5.25 5.25 0 0 0 0-10.5ZM4.3 11.7l7.4-7.4";
+    readonly top: "M3.5 2.75h9M8 13.25v-7.5M4.75 9 8 5.75 11.25 9";
+    readonly bottom: "M3.5 13.25h9M8 2.75v7.5M4.75 7 8 10.25 11.25 7";
+    readonly wrap: "M2.75 4h10.5M2.75 8h8.5a2 2 0 0 1 0 4H8.5M10 10.5 8.5 12l1.5 1.5M2.75 12h3";
+    readonly search: "M7 2.75a4.25 4.25 0 1 0 0 8.5 4.25 4.25 0 0 0 0-8.5ZM10.25 10.25l3 3";
+    readonly arrowDown: "M8 3.25v9.5M4.25 9 8 12.75 11.75 9";
+};
+export type IconName = keyof typeof ICON_PATHS;
+/** Creates an inline SVG icon. Icons are decorative; the control around them carries the name. */
+export declare const createIcon: (ownerDocument: Document, name: IconName) => SVGSVGElement;
+export {};

package/dist/viewer/icons.js

@@ -0,0 +1,30 @@
+const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+/** Path data for the toolbar icons, drawn on a 16 by 16 grid with a 1.5 stroke. */
+const ICON_PATHS = {
+    follow: 'M8 2.75v7.5M4.75 7 8 10.25 11.25 7M3.5 13.25h9',
+    clear: 'M8 2.75a5.25 5.25 0 1 0 0 10.5 5.25 5.25 0 0 0 0-10.5ZM4.3 11.7l7.4-7.4',
+    top: 'M3.5 2.75h9M8 13.25v-7.5M4.75 9 8 5.75 11.25 9',
+    bottom: 'M3.5 13.25h9M8 2.75v7.5M4.75 7 8 10.25 11.25 7',
+    wrap: 'M2.75 4h10.5M2.75 8h8.5a2 2 0 0 1 0 4H8.5M10 10.5 8.5 12l1.5 1.5M2.75 12h3',
+    search: 'M7 2.75a4.25 4.25 0 1 0 0 8.5 4.25 4.25 0 0 0 0-8.5ZM10.25 10.25l3 3',
+    arrowDown: 'M8 3.25v9.5M4.25 9 8 12.75 11.75 9'
+};
+/** Creates an inline SVG icon. Icons are decorative; the control around them carries the name. */
+export const createIcon = (ownerDocument, name) => {
+    const svg = ownerDocument.createElementNS(SVG_NAMESPACE, 'svg');
+    const path = ownerDocument.createElementNS(SVG_NAMESPACE, 'path');
+    svg.setAttribute('viewBox', '0 0 16 16');
+    svg.setAttribute('width', '16');
+    svg.setAttribute('height', '16');
+    svg.setAttribute('fill', 'none');
+    svg.setAttribute('aria-hidden', 'true');
+    svg.setAttribute('focusable', 'false');
+    svg.classList.add('lognal-icon');
+    path.setAttribute('d', ICON_PATHS[name]);
+    path.setAttribute('stroke', 'currentColor');
+    path.setAttribute('stroke-width', '1.5');
+    path.setAttribute('stroke-linecap', 'round');
+    path.setAttribute('stroke-linejoin', 'round');
+    svg.append(path);
+    return svg;
+};

package/dist/viewer/input-line.d.ts

@@ -0,0 +1,46 @@
+export interface InputLineOptions {
+    /** Called with the text when the user presses Enter. */
+    onSubmit: (text: string) => void;
+    /** The prompt drawn before the input. */
+    prompt: string;
+    placeholder: string;
+    label: string;
+    /** How many past commands ArrowUp and ArrowDown go through. */
+    historySize: number;
+}
+/**
+ * The line where the user types commands.
+ *
+ * It is a real `<textarea>`, so the browser handles focus, the caret, selection, paste and
+ * input method composition. Enter submits and Shift+Enter adds a line.
+ *
+ * Enter is ignored while an IME composition is open. Safari through version 26 fires
+ * `compositionend` before the `keydown` of the key that commits the composition, so that
+ * `keydown` reports `isComposing` as false. The input therefore also checks key code 229 and
+ * keeps treating the composition as open until the task after `compositionend`.
+ */
+export declare class InputLine {
+    private options;
+    readonly element: HTMLFormElement;
+    private readonly textarea;
+    private readonly promptElement;
+    private readonly history;
+    private historyIndex;
+    private draft;
+    private composing;
+    private compositionTimer;
+    constructor(ownerDocument: Document, options: InputLineOptions);
+    get value(): string;
+    setOptions(options: InputLineOptions): void;
+    focus(): void;
+    dispose(): void;
+    private submit;
+    private isComposing;
+    private showHistory;
+    private resize;
+    private readonly onFormSubmit;
+    private readonly onKeyDown;
+    private readonly onInput;
+    private readonly onCompositionStart;
+    private readonly onCompositionEnd;
+}

package/dist/viewer/input-line.js

@@ -0,0 +1,144 @@
+/** The most lines the input grows to before it scrolls. */
+const MAX_VISIBLE_LINES = 6;
+/** Key code browsers report for a key press that belongs to an IME composition. */
+const IME_KEY_CODE = 229;
+/**
+ * The line where the user types commands.
+ *
+ * It is a real `<textarea>`, so the browser handles focus, the caret, selection, paste and
+ * input method composition. Enter submits and Shift+Enter adds a line.
+ *
+ * Enter is ignored while an IME composition is open. Safari through version 26 fires
+ * `compositionend` before the `keydown` of the key that commits the composition, so that
+ * `keydown` reports `isComposing` as false. The input therefore also checks key code 229 and
+ * keeps treating the composition as open until the task after `compositionend`.
+ */
+export class InputLine {
+    options;
+    element;
+    textarea;
+    promptElement;
+    history = [];
+    historyIndex = -1;
+    draft = '';
+    composing = false;
+    compositionTimer;
+    constructor(ownerDocument, options) {
+        this.options = options;
+        this.element = ownerDocument.createElement('form');
+        this.element.className = 'lognal-input';
+        this.promptElement = ownerDocument.createElement('span');
+        this.promptElement.className = 'lognal-input-prompt';
+        this.promptElement.setAttribute('aria-hidden', 'true');
+        this.textarea = ownerDocument.createElement('textarea');
+        this.textarea.className = 'lognal-input-field';
+        this.textarea.rows = 1;
+        this.textarea.spellcheck = false;
+        this.textarea.setAttribute('autocomplete', 'off');
+        this.textarea.setAttribute('autocapitalize', 'off');
+        this.textarea.setAttribute('autocorrect', 'off');
+        this.element.append(this.promptElement, this.textarea);
+        this.setOptions(options);
+        this.element.addEventListener('submit', this.onFormSubmit);
+        this.textarea.addEventListener('keydown', this.onKeyDown);
+        this.textarea.addEventListener('input', this.onInput);
+        this.textarea.addEventListener('compositionstart', this.onCompositionStart);
+        this.textarea.addEventListener('compositionend', this.onCompositionEnd);
+    }
+    get value() {
+        return this.textarea.value;
+    }
+    setOptions(options) {
+        this.options = options;
+        this.promptElement.textContent = options.prompt;
+        this.textarea.placeholder = options.placeholder;
+        this.textarea.setAttribute('aria-label', options.label);
+    }
+    focus() {
+        this.textarea.focus();
+    }
+    dispose() {
+        clearTimeout(this.compositionTimer);
+        this.element.remove();
+    }
+    submit() {
+        const text = this.textarea.value;
+        if (!text.trim()) {
+            return;
+        }
+        if (this.history[this.history.length - 1] !== text) {
+            this.history.push(text);
+            if (this.history.length > this.options.historySize) {
+                this.history.shift();
+            }
+        }
+        this.historyIndex = -1;
+        this.draft = '';
+        this.textarea.value = '';
+        this.resize();
+        this.options.onSubmit(text);
+    }
+    isComposing(event) {
+        return this.composing || event.isComposing || event.keyCode === IME_KEY_CODE;
+    }
+    showHistory(index) {
+        if (this.historyIndex === -1) {
+            this.draft = this.textarea.value;
+        }
+        this.historyIndex = index;
+        this.textarea.value = index === -1 ? this.draft : this.history[index];
+        this.resize();
+        const end = this.textarea.value.length;
+        this.textarea.setSelectionRange(end, end);
+    }
+    resize() {
+        const lines = Math.min(MAX_VISIBLE_LINES, this.textarea.value.split('\n').length);
+        this.textarea.rows = Math.max(1, lines);
+    }
+    onFormSubmit = (event) => {
+        event.preventDefault();
+        this.submit();
+    };
+    onKeyDown = (event) => {
+        if (this.isComposing(event)) {
+            return;
+        }
+        const { selectionStart, selectionEnd, value } = this.textarea;
+        const caretCollapsed = selectionStart === selectionEnd;
+        if (event.key === 'Enter' && !event.shiftKey) {
+            event.preventDefault();
+            this.submit();
+            return;
+        }
+        if (event.key === 'ArrowUp' &&
+            caretCollapsed &&
+            !value.slice(0, selectionStart).includes('\n')) {
+            const next = this.historyIndex === -1 ? this.history.length - 1 : this.historyIndex - 1;
+            if (next >= 0) {
+                event.preventDefault();
+                this.showHistory(next);
+            }
+            return;
+        }
+        if (event.key === 'ArrowDown' && caretCollapsed && !value.slice(selectionEnd).includes('\n')) {
+            if (this.historyIndex === -1) {
+                return;
+            }
+            event.preventDefault();
+            this.showHistory(this.historyIndex + 1 < this.history.length ? this.historyIndex + 1 : -1);
+        }
+    };
+    onInput = () => {
+        this.resize();
+    };
+    onCompositionStart = () => {
+        clearTimeout(this.compositionTimer);
+        this.composing = true;
+    };
+    onCompositionEnd = () => {
+        clearTimeout(this.compositionTimer);
+        this.compositionTimer = setTimeout(() => {
+            this.composing = false;
+        }, 0);
+    };
+}

package/dist/viewer/labels.d.ts

@@ -0,0 +1,35 @@
+/** The text of the viewer's controls. Every label is used as visible text or an accessible name. */
+export interface ViewerLabels {
+    /** Accessible name of the whole viewer. */
+    viewer: string;
+    /** Accessible name of the toolbar. */
+    toolbar: string;
+    follow: string;
+    clear: string;
+    scrollToTop: string;
+    scrollToBottom: string;
+    wrap: string;
+    filter: string;
+    invalidFilter: string;
+    levels: string;
+    levelAll: string;
+    levelLog: string;
+    levelInfo: string;
+    levelWarn: string;
+    levelError: string;
+    /** Accessible name of the input line. */
+    input: string;
+    inputPlaceholder: string;
+    /** The button that appears when new entries arrive while the view is scrolled up. */
+    newLogs: string;
+    /** Accessible name of the list that mirrors the visible entries for screen readers. */
+    entryList: string;
+    following: string;
+    paused: string;
+    /** The entry count in the status bar. `format` formats a number for the locale. */
+    entries: (shown: number, total: number, format: (value: number) => string) => string;
+}
+export declare const EN_LABELS: ViewerLabels;
+export declare const KO_LABELS: ViewerLabels;
+/** Returns the built-in labels for a language tag. English is used for any other language. */
+export declare const labelsFor: (locale: string | undefined) => ViewerLabels;