@fusion.dev/helix-headless 0.199.1 → 0.200.0

package/dist/log/root/log-root.js

@@ -0,0 +1,772 @@
+var HelixHeadlessLog_1;
+import { __decorate } from "tslib";
+import { customElement, drawIcon, formatWords, HelixBeforePinEvent, HelixElement, HelixExpandEvent, HelixPinEvent, hostAria, MixinCollection, onUnlessFalse, requestChange, SCROLLER_RULE, VIRTUAL_RULE, VirtualizeController, whenHydrated, words, } from '@fusion.dev/helix-core';
+import { arrowDown } from '@fusion.dev/helix-icons';
+import { nothing } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { keyed } from 'lit/directives/keyed.js';
+import { repeat } from 'lit/directives/repeat.js';
+import { html } from 'lit/static-html.js';
+import { lineRuns } from '../../code-block/lines.js';
+import { stripAnsi } from '../ansi.js';
+import { LogBuffer, } from '../buffer.js';
+import { timeOf } from '../line/log-line.js';
+import { logRows } from '../rows.js';
+const STATUS_NAMES = {
+    done: 'summary: group-summary-done',
+    failed: 'summary: group-summary-failed',
+    pending: 'summary: group-summary-pending',
+    running: 'summary: group-summary-running',
+    skipped: 'summary: group-summary-skipped',
+};
+const secondNames = (table, key) => key !== undefined && Object.hasOwn(table, key) ? `, ${table[key]}` : '';
+const inRuns = (runs, number) => runs.some(([first, last]) => number >= first && number <= last);
+let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixElement) {
+    constructor() {
+        super(...arguments);
+        this.defaultPinned = true;
+        this.doneLabel = 'Finished';
+        this.droppedLabel = '{count, plural, one {# earlier line is} other {# earlier lines are}} not kept';
+        this.emptyText = 'No output yet';
+        this.errorLabel = '{count, plural, one {Error} other {# errors}}: {text}';
+        this.fallbackLabel = 'Log';
+        this.groupLabel = '{status, select, failed {{heading} failed} other {{heading} finished}}';
+        this.groups = [];
+        this.label = '';
+        this.limit = 0;
+        this.lineHref = '';
+        this.lineLabel = 'Line {number}';
+        this.lineNumbers = false;
+        this.markLines = '';
+        this.matchesLabel = '{count, plural, =0 {No lines match} one {# line matches} other {# lines match}}';
+        this.query = '';
+        this.resumeLabel = 'Jump to latest';
+        this.threshold = 48;
+        this.wrap = false;
+        this.pinnedState = undefined;
+        this.doneState = undefined;
+        this.reading = false;
+        this.announcement = '';
+        this.said = 0;
+        this.buffer = new LogBuffer();
+        this.sourceValue = null;
+        this.readToken = 0;
+        this.stopReading = undefined;
+        this.opened = new Map();
+        this.view = { matched: 0, rows: [] };
+        this.fresh = false;
+        this.droppedBefore = 0;
+        this.owed = 0;
+        this.childLines = [];
+        this.childGroups = [];
+        this.watcher = undefined;
+        this.grower = undefined;
+        this.stuckAt = -1;
+        this.opening = true;
+        this.heard = undefined;
+        this.virtualize = new VirtualizeController(this, {
+            anchor: () => !this.pinned,
+            container: () => (this.fed ? this.log : null),
+            count: () => this.view.rows.length,
+            estimate: () => HelixHeadlessLog_1.ESTIMATE,
+            measured: () => this.wrap,
+            rows: () => (this.fed ? this.drawn() : []),
+        });
+        this.handleResize = () => {
+            this.markScroller();
+            if (this.pinned) {
+                this.stick();
+            }
+        };
+        this.handleMutation = () => {
+            this.requestUpdate();
+        };
+        this.handleScroll = () => {
+            const log = this.log;
+            if (this.pinned && log && log.scrollTop >= this.stuckAt - 1 && !this.atBottom) {
+                this.stick();
+                return;
+            }
+            const wanted = this.atBottom;
+            if (wanted !== this.pinned) {
+                this.requestPinned(wanted);
+            }
+        };
+        this.handleResume = () => {
+            this.resume();
+        };
+        this.handleGroupToggle = (event) => {
+            const group = event.currentTarget;
+            const id = group.dataset.group;
+            if (id === undefined || this.query.trim() !== '') {
+                return;
+            }
+            this.opened.set(id, group.open);
+            this.requestUpdate();
+            const open = this.groups.filter((each) => this.isOpen(each.id)).map((each) => each.id);
+            this.dispatchEvent(new HelixExpandEvent({ value: open.join(',') }));
+        };
+    }
+    static { HelixHeadlessLog_1 = this; }
+    static { this.markRules = [SCROLLER_RULE, VIRTUAL_RULE]; }
+    static { this.words = 'helix-log'; }
+    static { this.ESTIMATE = 20; }
+    get done() {
+        return this.doneState ?? false;
+    }
+    set done(next) {
+        const previous = this.done;
+        this.doneState = next;
+        this.requestUpdate('done', previous);
+    }
+    get lines() {
+        return this.buffer.lines;
+    }
+    set lines(next) {
+        const previous = this.buffer.lines;
+        this.buffer.replace(next ?? []);
+        this.fresh = true;
+        this.requestUpdate('lines', previous);
+    }
+    get parse() {
+        return this.buffer.parse;
+    }
+    set parse(next) {
+        const previous = this.buffer.parse;
+        this.buffer.parse = next;
+        this.requestUpdate('parse', previous);
+    }
+    get pinned() {
+        return this.pinnedState ?? this.defaultPinned;
+    }
+    set pinned(next) {
+        const previous = this.pinned;
+        this.pinnedState = next;
+        this.requestUpdate('pinned', previous);
+    }
+    get source() {
+        return this.sourceValue;
+    }
+    set source(next) {
+        const previous = this.sourceValue;
+        this.sourceValue = next ?? null;
+        this.requestUpdate('source', previous);
+        if (this.isConnected && next !== previous) {
+            void this.readSource(this.sourceValue);
+        }
+    }
+    get fed() {
+        return (this.buffer.lines.length > 0 ||
+            this.buffer.current() !== undefined ||
+            this.groups.length > 0 ||
+            this.sourceValue !== null);
+    }
+    get log() {
+        return this.partNamed('log');
+    }
+    get text() {
+        if (this.fed) {
+            const current = this.buffer.current();
+            return [...this.buffer.lines, ...(current ? [current] : [])]
+                .map((line) => stripAnsi(line.text))
+                .join('\n');
+        }
+        return this.childLines.map((line) => (line.textContent ?? '').trim()).join('\n');
+    }
+    write(chunk) {
+        if (chunk === '') {
+            return;
+        }
+        this.buffer.write(chunk);
+        this.requestUpdate();
+    }
+    clear() {
+        this.buffer.clear();
+        this.opened.clear();
+        this.fresh = true;
+        this.droppedBefore = 0;
+        this.requestUpdate();
+    }
+    resume() {
+        this.stick();
+        this.requestPinned(true);
+    }
+    async scrollToLine(number, options = {}) {
+        const align = options.align ?? 'center';
+        if (this.fed) {
+            const line = this.buffer.lines[number - this.buffer.dropped - 1];
+            if (line?.group !== undefined && !this.isOpen(line.group)) {
+                this.opened.set(line.group, true);
+                this.requestUpdate();
+                await this.updateComplete;
+            }
+            const index = this.view.rows.findIndex((row) => row.kind === 'line' && row.number === number);
+            if (index < 0) {
+                return false;
+            }
+            if (this.pinned && this.requestPinned(false)) {
+                await this.updateComplete;
+            }
+            this.virtualize.reveal(index, 0, {
+                align,
+                ...(options.behavior ? { behavior: options.behavior } : {}),
+            });
+            return true;
+        }
+        const line = this.childLines[number - 1];
+        if (!line || line.logFiltered) {
+            return false;
+        }
+        for (const group of this.childGroups) {
+            if (!group.open && group.contains(line)) {
+                group.open = true;
+            }
+        }
+        if (this.pinned && this.requestPinned(false)) {
+            await this.updateComplete;
+        }
+        await line.updateComplete;
+        const log = this.log;
+        if (log) {
+            const box = log.getBoundingClientRect();
+            const rect = line.getBoundingClientRect();
+            const offset = align === 'start'
+                ? rect.top - box.top
+                : align === 'end'
+                    ? rect.bottom - box.bottom
+                    : align === 'nearest'
+                        ? Math.min(0, rect.top - box.top) || Math.max(0, rect.bottom - box.bottom)
+                        : rect.top - box.top - (box.height - rect.height) / 2;
+            if (options.behavior && typeof log.scrollBy === 'function') {
+                log.scrollBy({ behavior: options.behavior, top: offset });
+            }
+            else {
+                log.scrollTop += offset;
+            }
+        }
+        return true;
+    }
+    isOpen(id) {
+        const known = this.opened.get(id);
+        if (known !== undefined) {
+            return known;
+        }
+        const seeded = this.groups.find((group) => group.id === id)?.open ?? false;
+        this.opened.set(id, seeded);
+        return seeded;
+    }
+    reopen(previous) {
+        const before = new Map((previous ?? []).map((group) => [group.id, group.open]));
+        for (const group of this.groups) {
+            if (group.open !== undefined && before.has(group.id) && before.get(group.id) !== group.open) {
+                this.opened.set(group.id, group.open);
+            }
+        }
+    }
+    get atBottom() {
+        const log = this.log;
+        if (!log) {
+            return true;
+        }
+        return log.scrollHeight - log.scrollTop - log.clientHeight <= Math.max(0, this.threshold);
+    }
+    stick() {
+        const log = this.log;
+        if (log) {
+            log.scrollTop = log.scrollHeight;
+            this.stuckAt = log.scrollTop;
+        }
+    }
+    requestPinned(next) {
+        if (next === this.pinned) {
+            return false;
+        }
+        return requestChange({
+            apply: (value) => {
+                const previous = this.pinned;
+                this.pinnedState = value;
+                this.requestUpdate('pinned', previous);
+                this.dispatchEvent(new HelixPinEvent({ value: String(value) }));
+            },
+            event: (value) => new HelixBeforePinEvent({ value: String(value) }),
+            host: this,
+            next,
+        });
+    }
+    drawn() {
+        return [...(this.renderRoot?.querySelectorAll?.('[part="row"]') ?? [])].map((element) => ({ element, index: Number(element.dataset.index) }));
+    }
+    readChildren() {
+        if (!this.childrenKnown) {
+            this.childLines = [];
+            this.childGroups = [];
+            return;
+        }
+        const lines = [];
+        const groups = [];
+        for (const element of this.querySelectorAll('*')) {
+            if ('isLogLine' in element && element.isLogLine === true) {
+                lines.push(element);
+            }
+            else if ('isLogGroup' in element && element.isLogGroup === true) {
+                groups.push(element);
+            }
+        }
+        this.childLines = lines;
+        this.childGroups = groups;
+    }
+    tellLines() {
+        const marks = lineRuns(this.markLines);
+        const needle = this.query.trim().toLowerCase();
+        const start = this.childLines.map((line) => timeOf(line.at)).find((time) => time !== undefined);
+        this.childLines.forEach((line, at) => {
+            const filtered = needle !== '' && !(line.textContent ?? '').toLowerCase().includes(needle);
+            whenHydrated(line, () => {
+                line.logNumber = at + 1;
+                line.logNumbers = this.lineNumbers;
+                line.logHref = this.lineHref;
+                line.logTimes = this.timestamps ?? '';
+                line.logStart = start;
+                line.logMarked = inRuns(marks, at + 1);
+                line.logFiltered = filtered;
+            });
+            if (!filtered && needle !== '') {
+                for (const group of this.childGroups) {
+                    if (!group.open && group.contains(line)) {
+                        whenHydrated(group, () => {
+                            group.open = true;
+                        });
+                    }
+                }
+            }
+        });
+    }
+    markScroller() {
+        const log = this.log;
+        if (!log) {
+            return;
+        }
+        if (log.scrollHeight > log.clientHeight || log.scrollWidth > log.clientWidth) {
+            log.tabIndex = 0;
+        }
+        else {
+            log.removeAttribute('tabindex');
+        }
+    }
+    listen() {
+        const groups = new Map();
+        if (this.fed) {
+            for (const group of this.groups) {
+                groups.set(group.id, { heading: group.heading, status: group.status });
+            }
+        }
+        else {
+            for (const group of this.childGroups) {
+                groups.set(group, {
+                    heading: group.heading || (group.textContent ?? '').trim(),
+                    status: group.status,
+                });
+            }
+        }
+        return {
+            done: this.done,
+            groups,
+            matched: this.fed
+                ? this.view.matched
+                : this.childLines.filter((line) => !line.logFiltered).length,
+            query: this.query,
+            total: this.fed ? this.buffer.dropped + this.buffer.lines.length : this.childLines.length,
+        };
+    }
+    announce() {
+        const now = this.listen();
+        const before = this.heard;
+        this.heard = now;
+        if (this.opening || !before) {
+            return;
+        }
+        const said = [];
+        if (now.query !== before.query && now.query.trim() !== '') {
+            said.push(formatWords(this, 'matchesLabel', { count: now.matched }));
+        }
+        const arrived = now.total - before.total;
+        if (arrived > 0) {
+            const fresh = this.fed
+                ? this.buffer.lines.slice(Math.max(0, this.buffer.lines.length - arrived))
+                : this.childLines.slice(before.total).map((line) => ({
+                    level: line.level,
+                    text: (line.textContent ?? '').trim(),
+                }));
+            const errors = fresh.filter((line) => line.level === 'error');
+            if (errors.length > 0) {
+                said.push(formatWords(this, 'errorLabel', {
+                    count: errors.length,
+                    text: stripAnsi(errors[0]?.text ?? ''),
+                }));
+            }
+        }
+        for (const [id, group] of now.groups) {
+            const was = before.groups.get(id)?.status;
+            if (group.status !== was &&
+                (group.status === 'done' || group.status === 'failed') &&
+                before.groups.has(id)) {
+                said.push(formatWords(this, 'groupLabel', { heading: group.heading, status: group.status }));
+            }
+        }
+        if (now.done && !before.done) {
+            said.push(this.doneLabel);
+        }
+        if (said.length > 0) {
+            this.announcement = said.join(' ');
+            this.said += 1;
+        }
+    }
+    async readSource(source) {
+        this.stopReading?.();
+        this.stopReading = undefined;
+        this.readToken += 1;
+        const token = this.readToken;
+        this.reading = source !== null;
+        if (!source) {
+            return;
+        }
+        const decoder = new TextDecoder();
+        const take = (chunk) => {
+            if (token !== this.readToken) {
+                return false;
+            }
+            this.write(typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true }));
+            return true;
+        };
+        try {
+            if ('getReader' in source) {
+                const reader = source.getReader();
+                this.stopReading = () => {
+                    reader.cancel().catch(() => undefined);
+                };
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done || !take(value)) {
+                        break;
+                    }
+                }
+            }
+            else {
+                for await (const chunk of source) {
+                    if (!take(chunk)) {
+                        break;
+                    }
+                }
+            }
+            if (token === this.readToken) {
+                this.write(decoder.decode());
+                this.done = true;
+            }
+        }
+        catch (error) {
+            if (token === this.readToken) {
+                globalThis.reportError?.(error);
+            }
+        }
+        finally {
+            if (token === this.readToken) {
+                this.reading = false;
+                this.stopReading = undefined;
+            }
+        }
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.watcher = new MutationObserver(this.handleMutation);
+        this.watcher.observe(this, {
+            attributeFilter: ['status', 'level'],
+            childList: true,
+            subtree: true,
+        });
+        this.opening = true;
+        requestAnimationFrame(() => {
+            this.opening = false;
+        });
+        if (this.sourceValue !== null && !this.reading) {
+            void this.readSource(this.sourceValue);
+        }
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.watcher?.disconnect();
+        this.watcher = undefined;
+        this.grower?.disconnect();
+        this.grower = undefined;
+        this.stopReading?.();
+        this.stopReading = undefined;
+        this.readToken += 1;
+        this.reading = false;
+    }
+    willUpdate(changed) {
+        super.willUpdate(changed);
+        hostAria(this.internals, { label: this.label || this.fallbackLabel, role: 'region' });
+        if (changed.has('groups')) {
+            this.reopen(changed.get('groups'));
+        }
+        if (changed.has('limit')) {
+            this.buffer.limit = Math.max(0, Math.floor(this.limit || 0));
+            this.buffer.write('');
+        }
+        if (!this.fed) {
+            this.readChildren();
+        }
+        const dropped = this.buffer.dropped - this.droppedBefore;
+        if (this.fresh) {
+            this.fresh = false;
+            this.virtualize.forget();
+        }
+        else if (dropped > 0) {
+            if (!this.pinned) {
+                this.owed += dropped * this.virtualize.sizeOf(0);
+            }
+            if (this.wrap) {
+                this.virtualize.forget();
+            }
+        }
+        this.droppedBefore = this.buffer.dropped;
+        if (this.fed) {
+            this.view = logRows({
+                current: this.buffer.current(),
+                groups: this.groups,
+                lines: this.buffer.lines,
+                open: (id) => this.isOpen(id),
+                query: this.query,
+                start: this.buffer.dropped,
+            });
+        }
+        else {
+            this.view = { matched: 0, rows: [] };
+        }
+        this.toggleState('pinned', this.pinned);
+        this.toggleState('done', this.done);
+        this.toggleState('filtered', this.query.trim() !== '');
+        this.toggleState('empty', this.childrenKnown && !this.fed && this.childLines.length === 0);
+    }
+    updated(changed) {
+        super.updated(changed);
+        if (!this.fed) {
+            this.tellLines();
+        }
+        const log = this.log;
+        if (this.pinned) {
+            this.stick();
+        }
+        else if (this.owed > 0 && log) {
+            log.scrollTop = Math.max(0, log.scrollTop - this.owed);
+        }
+        this.owed = 0;
+        if (this.fed) {
+            this.virtualize.measure();
+        }
+        if (log && typeof ResizeObserver !== 'undefined' && !this.grower) {
+            this.grower = new ResizeObserver(this.handleResize);
+            this.grower.observe(log);
+        }
+        this.markScroller();
+        this.announce();
+    }
+    renderRow(row, marks, start) {
+        if (row.kind === 'group') {
+            const group = this.tag('log-group');
+            const { duration, heading, id, status } = row.group;
+            return html `<${group}
+        exportparts="content: group-content, duration: group-duration, heading: group-heading,
+          mark: group-mark, status: group-status, summary: group-summary${secondNames(STATUS_NAMES, status)}"
+        data-group=${id}
+        duration=${duration ?? nothing}
+        heading=${heading}
+        status=${status ?? nothing}
+        .logDrawn=${true}
+        .open=${row.open}
+        @toggle=${this.handleGroupToggle}
+      ></${group}>`;
+        }
+        const line = this.tag('log-line');
+        const { at, level } = row.line;
+        return html `<${line}
+      exportparts="line, line-debug, line-error, line-marked, line-warn, match: line-match,
+        number: line-number, run: line-run, run-bold: line-run-bold, run-dim: line-run-dim,
+        run-italic: line-run-italic, run-strike: line-run-strike, run-underline: line-run-underline,
+        text: line-text, time: line-time"
+      level=${level ?? nothing}
+      .at=${at ?? ''}
+      .lineLabel=${this.lineLabel}
+      .logHref=${this.lineHref}
+      .logMarked=${inRuns(marks, row.number)}
+      .logNumber=${row.number}
+      .logNumbers=${this.lineNumbers}
+      .logQuery=${this.query}
+      .logStart=${start}
+      .logTimes=${this.timestamps ?? ''}
+      .runs=${this.buffer.runsOf(row.line)}
+    ></${line}>`;
+    }
+    get firstTime() {
+        for (const line of this.buffer.lines) {
+            const time = timeOf(line.at);
+            if (time !== undefined) {
+                return time;
+            }
+        }
+        return undefined;
+    }
+    get digits() {
+        if (!this.lineNumbers) {
+            return 0;
+        }
+        const largest = this.fed
+            ? this.buffer.dropped + this.buffer.lines.length + 1
+            : this.childLines.length;
+        return largest > 0 ? String(largest).length : 0;
+    }
+    renderRows() {
+        const { after, before, first, last } = this.virtualize.window;
+        const marks = lineRuns(this.markLines);
+        const start = this.timestamps === 'relative' ? this.firstTime : undefined;
+        return html `<div part="before" role="presentation" style="block-size: ${before}px; flex: none"></div>
+      ${repeat(this.view.rows.slice(first, last), (row) => (row.kind === 'group' ? `group:${row.group.id}` : `line:${row.number}`), (row, offset) => html `<div part="row" data-index=${first + offset}>${this.renderRow(row, marks, start)}</div>`)}
+      <div part="after" role="presentation" style="block-size: ${after}px; flex: none"></div>`;
+    }
+    renderResume() {
+        return html `<slot name="resume"
+      ><button part="resume-button" type="button">
+        <span part="resume-mark" aria-hidden="true">${drawIcon(arrowDown)}</span>${this.resumeLabel}
+      </button></slot
+    >`;
+    }
+    render() {
+        const fed = this.fed;
+        const dropped = this.buffer.dropped;
+        const content = this.query.trim() !== '' ||
+            (fed ? this.view.rows.length > 0 : this.childLines.length > 0 || !this.childrenKnown);
+        return html `<slot name="toolbar" part="toolbar"></slot>
+      <p part="dropped" ?hidden=${dropped === 0}>${dropped === 0 ? nothing : formatWords(this, 'droppedLabel', { count: dropped })}</p>
+      <div
+        part="log"
+        role="log"
+        aria-live="off"
+        data-scroller
+        aria-label=${this.label || this.fallbackLabel}
+        aria-busy=${this.reading && !this.done ? 'true' : nothing}
+        style=${this.digits === 0 ? nothing : `--log-digits: ${this.digits}`}
+        ?data-windowed=${fed}
+        @scroll=${this.handleScroll}
+      >
+        ${fed ? this.renderRows() : nothing}
+        <slot></slot>
+        ${this.renderStatus(content)}
+      </div>
+      <span part="live" role="status">${keyed(this.said, this.announcement)}</span>
+      <div part="resume" ?hidden=${this.pinned} @click=${this.handleResume}>
+        ${this.renderResume()}
+      </div>`;
+    }
+};
+__decorate([
+    property({ attribute: 'default-pinned', converter: onUnlessFalse })
+], HelixHeadlessLog.prototype, "defaultPinned", void 0);
+__decorate([
+    property({ type: Boolean })
+], HelixHeadlessLog.prototype, "done", null);
+__decorate([
+    words,
+    property({ attribute: 'done-label' })
+], HelixHeadlessLog.prototype, "doneLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'dropped-label' })
+], HelixHeadlessLog.prototype, "droppedLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'empty-text' })
+], HelixHeadlessLog.prototype, "emptyText", void 0);
+__decorate([
+    words,
+    property({ attribute: 'error-label' })
+], HelixHeadlessLog.prototype, "errorLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'fallback-label' })
+], HelixHeadlessLog.prototype, "fallbackLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'group-label' })
+], HelixHeadlessLog.prototype, "groupLabel", void 0);
+__decorate([
+    property({ attribute: false })
+], HelixHeadlessLog.prototype, "groups", void 0);
+__decorate([
+    property()
+], HelixHeadlessLog.prototype, "label", void 0);
+__decorate([
+    property({ type: Number })
+], HelixHeadlessLog.prototype, "limit", void 0);
+__decorate([
+    property({ attribute: 'line-href' })
+], HelixHeadlessLog.prototype, "lineHref", void 0);
+__decorate([
+    words,
+    property({ attribute: 'line-label' })
+], HelixHeadlessLog.prototype, "lineLabel", void 0);
+__decorate([
+    property({ attribute: 'line-numbers', type: Boolean })
+], HelixHeadlessLog.prototype, "lineNumbers", void 0);
+__decorate([
+    property({ attribute: false })
+], HelixHeadlessLog.prototype, "lines", null);
+__decorate([
+    property({ attribute: 'mark-lines' })
+], HelixHeadlessLog.prototype, "markLines", void 0);
+__decorate([
+    words,
+    property({ attribute: 'matches-label' })
+], HelixHeadlessLog.prototype, "matchesLabel", void 0);
+__decorate([
+    property({ attribute: false })
+], HelixHeadlessLog.prototype, "parse", null);
+__decorate([
+    property({ type: Boolean })
+], HelixHeadlessLog.prototype, "pinned", null);
+__decorate([
+    property()
+], HelixHeadlessLog.prototype, "query", void 0);
+__decorate([
+    words,
+    property({ attribute: 'resume-label' })
+], HelixHeadlessLog.prototype, "resumeLabel", void 0);
+__decorate([
+    property({ attribute: false })
+], HelixHeadlessLog.prototype, "source", null);
+__decorate([
+    property({ type: Number })
+], HelixHeadlessLog.prototype, "threshold", void 0);
+__decorate([
+    property()
+], HelixHeadlessLog.prototype, "timestamps", void 0);
+__decorate([
+    property({ reflect: true, type: Boolean })
+], HelixHeadlessLog.prototype, "wrap", void 0);
+__decorate([
+    state()
+], HelixHeadlessLog.prototype, "pinnedState", void 0);
+__decorate([
+    state()
+], HelixHeadlessLog.prototype, "doneState", void 0);
+__decorate([
+    state()
+], HelixHeadlessLog.prototype, "reading", void 0);
+__decorate([
+    state()
+], HelixHeadlessLog.prototype, "announcement", void 0);
+__decorate([
+    state()
+], HelixHeadlessLog.prototype, "said", void 0);
+HelixHeadlessLog = HelixHeadlessLog_1 = __decorate([
+    customElement('helix-headless-log')
+], HelixHeadlessLog);
+export { HelixHeadlessLog };