@fusion.dev/helix-headless 0.208.1 → 0.210.0

package/dist/terminal/root/terminal-root.js

@@ -0,0 +1,710 @@
+import { __decorate } from "tslib";
+import { CopyController, customElement, drawIcon, FullscreenController, formatWords, HelixElement, HelixTerminalBellEvent, HelixTerminalInputEvent, HelixTerminalLinkEvent, HelixTerminalResizeEvent, HelixTerminalRestartEvent, HelixTerminalTitleEvent, numberConverter, onApple, words, } from '@fusion.dev/helix-core';
+import { arrowClockwise, broom, caretDown, caretUp, copy, cornersOut, magnifyingGlass, x, } from '@fusion.dev/helix-icons';
+import { nothing } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { keyed } from 'lit/directives/keyed.js';
+import { live } from 'lit/directives/live.js';
+import { html } from 'lit/static-html.js';
+import '../../button/index.js';
+import '../../icon-button/index.js';
+import '../../toolbar/index.js';
+import { isTab, shortcutOf, spokenChord } from '../keys.js';
+const ANSI = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'];
+const camel = (name) => name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+const unset = (color) => color === '' || color === 'transparent' || /^rgba\(\s*0,\s*0,\s*0,\s*0\s*\)$/.test(color);
+const stopPress = (event) => event.stopPropagation();
+const BELL = 200;
+const RESTING_CONTROLS = 'find clear';
+const opens = (href) => /^https?:\/\//i.test(href);
+let HelixHeadlessTerminal = class HelixHeadlessTerminal extends HelixElement {
+    constructor() {
+        super(...arguments);
+        this.clearLabel = 'Clear';
+        this.controlsLabel = 'Terminal controls';
+        this.copiedLabel = 'Copied';
+        this.copyLabel = 'Copy';
+        this.exitedLabel = '{code, select, 0 {The process exited.} other {The process exited with code {code}.}}';
+        this.fallbackLabel = 'Terminal';
+        this.findCloseLabel = 'Close find';
+        this.findControlsLabel = 'Find controls';
+        this.findLabel = 'Find';
+        this.findNextLabel = 'Next match';
+        this.findPreviousLabel = 'Previous match';
+        this.fullscreenLabel = 'Fill the screen';
+        this.inputLabel = 'Terminal input';
+        this.label = '';
+        this.matchesLabel = '{count, plural, =0 {No matches} one {{index} of # match} other {{index} of # matches}}';
+        this.readOnly = false;
+        this.restartLabel = 'Restart';
+        this.screenReaderMode = false;
+        this.tabHintLabel = 'Press {key} to move focus with Tab.';
+        this.tabMovesFocusLabel = 'Tab moves focus. Press {key} to type Tab in the terminal.';
+        this.tabTypesLabel = 'Tab types in the terminal.';
+        this.findOpen = false;
+        this.query = '';
+        this.matchIndex = -1;
+        this.matchCount = undefined;
+        this.tabMovesFocus = false;
+        this.anySelected = false;
+        this.hasActions = false;
+        this.hasLabel = false;
+        this.announcement = '';
+        this.said = 0;
+        this.renderer = undefined;
+        this.pending = [];
+        this.inputWas = undefined;
+        this.ringing = undefined;
+        this.copier = new CopyController(this);
+        this.filled = false;
+        this.fullscreen = new FullscreenController(this, (full) => {
+            this.filled = full;
+            this.toggleState('fullscreen', full);
+        });
+        this.handleKeys = (event) => {
+            if (event.defaultPrevented || event.isComposing) {
+                return;
+            }
+            const origin = event.composedPath()[0];
+            const inGrid = origin instanceof Node &&
+                [...this.children].some((child) => !child.slot && child.contains(origin));
+            const shortcut = shortcutOf(event, onApple());
+            if (shortcut === 'find' && this.takes('find')) {
+                event.preventDefault();
+                event.stopPropagation();
+                void this.openFind();
+                return;
+            }
+            if (!inGrid || !this.renderer) {
+                return;
+            }
+            if (shortcut === 'copy' && this.takes('copy')) {
+                event.preventDefault();
+                event.stopPropagation();
+                void this.copySelection();
+                return;
+            }
+            if (shortcut === 'tab-focus') {
+                event.preventDefault();
+                event.stopPropagation();
+                this.tabMovesFocus = !this.tabMovesFocus;
+                this.say(this.tabMovesFocus
+                    ? formatWords(this, 'tabMovesFocusLabel', { key: this.tabKey })
+                    : this.tabTypesLabel);
+                return;
+            }
+            if (this.tabMovesFocus && isTab(event)) {
+                event.stopPropagation();
+            }
+        };
+        this.handleFindInput = (event) => {
+            this.query = event.target.value;
+            this.search(false, true);
+        };
+        this.handleFindKeys = (event) => {
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                this.closeFind();
+            }
+            else if (event.key === 'Enter') {
+                event.preventDefault();
+                this.search(event.shiftKey);
+            }
+        };
+        this.handleActions = (event) => {
+            this.hasActions = event.target.assignedNodes().length > 0;
+        };
+        this.handleLabel = (event) => {
+            this.hasLabel = event.target.assignedNodes().length > 0;
+        };
+        this.handleRestart = () => {
+            this.dispatchEvent(new HelixTerminalRestartEvent());
+        };
+    }
+    static { this.words = 'helix-terminal'; }
+    write(data) {
+        return new Promise((resolve) => {
+            if (this.renderer) {
+                this.renderer.write(data, resolve);
+            }
+            else {
+                this.pending.push({ data, done: resolve });
+            }
+        });
+    }
+    paste(text) {
+        if (this.renderer?.paste) {
+            this.renderer.paste(text);
+        }
+        else {
+            this.send(text, false);
+        }
+    }
+    clear() {
+        this.renderer?.clear?.();
+    }
+    reset() {
+        this.renderer?.reset?.();
+    }
+    text(scope = 'screen') {
+        return this.renderer?.text?.(scope) ?? '';
+    }
+    look() {
+        const colors = {};
+        for (const probe of this.renderRoot.querySelectorAll('[data-look] > [data-color]')) {
+            const color = getComputedStyle(probe).color;
+            if (!unset(color)) {
+                colors[camel(probe.dataset.color ?? '')] = color;
+            }
+        }
+        const viewport = this.partNamed('viewport');
+        const face = viewport ? getComputedStyle(viewport) : undefined;
+        const size = face ? Number.parseFloat(face.fontSize) : Number.NaN;
+        return {
+            colors,
+            font: face && Number.isFinite(size) ? { family: face.fontFamily, size } : undefined,
+        };
+    }
+    focus(options) {
+        if (this.renderer?.focus) {
+            this.renderer.focus();
+            return;
+        }
+        const input = this.renderer?.input?.();
+        if (input) {
+            input.focus(options);
+            return;
+        }
+        super.focus(options);
+    }
+    attach(renderer) {
+        this.release();
+        this.renderer = renderer;
+        for (const { data, done } of this.pending.splice(0)) {
+            renderer.write(data, done);
+        }
+        renderer.settings?.(this.settings);
+        this.nameInput();
+        const current = () => this.renderer === renderer;
+        return {
+            bell: () => {
+                if (current()) {
+                    this.ring();
+                }
+            },
+            detach: () => {
+                if (current()) {
+                    this.release();
+                    this.renderer = undefined;
+                }
+            },
+            found: (index, count) => {
+                if (current()) {
+                    this.matchIndex = index;
+                    this.matchCount = count;
+                    this.say(this.countText);
+                }
+            },
+            input: (data, binary = false) => {
+                if (current()) {
+                    this.send(data, binary);
+                }
+            },
+            link: (href) => {
+                if (current()) {
+                    this.follow(href);
+                }
+            },
+            resized: (size) => {
+                if (current()) {
+                    this.dispatchEvent(new HelixTerminalResizeEvent(size));
+                }
+            },
+            selected: (any) => {
+                if (current()) {
+                    this.anySelected = any;
+                }
+            },
+            title: (title) => {
+                if (current()) {
+                    this.dispatchEvent(new HelixTerminalTitleEvent({ title }));
+                }
+            },
+        };
+    }
+    get settings() {
+        const fixed = this.columns !== undefined && this.rows !== undefined;
+        return {
+            columns: fixed ? this.columns : undefined,
+            cursor: !this.readOnly,
+            input: !this.readOnly && this.exitCode === undefined,
+            rows: fixed ? this.rows : undefined,
+            screenReader: this.screenReaderMode,
+        };
+    }
+    send(data, binary) {
+        if (this.readOnly || this.exitCode !== undefined || data === '') {
+            return;
+        }
+        this.dispatchEvent(new HelixTerminalInputEvent({ binary, data }));
+    }
+    follow(href) {
+        const event = new HelixTerminalLinkEvent({ href });
+        this.dispatchEvent(event);
+        if (!event.defaultPrevented && opens(href)) {
+            window.open(href, '_blank', 'noopener,noreferrer');
+        }
+    }
+    ring() {
+        clearTimeout(this.ringing);
+        this.toggleState('bell', true);
+        this.ringing = setTimeout(() => this.toggleState('bell', false), BELL);
+        this.dispatchEvent(new HelixTerminalBellEvent());
+    }
+    say(text) {
+        this.announcement = text;
+        this.said += 1;
+    }
+    draws(control) {
+        if (!(this.controls ?? RESTING_CONTROLS).split(/\s+/).includes(control)) {
+            return false;
+        }
+        const renderer = this.renderer;
+        if (!renderer || control === 'fullscreen') {
+            return true;
+        }
+        return control === 'clear'
+            ? renderer.clear !== undefined
+            : control === 'copy'
+                ? renderer.selection !== undefined
+                : renderer.find !== undefined;
+    }
+    get countText() {
+        return this.matchCount === undefined
+            ? ''
+            : formatWords(this, 'matchesLabel', {
+                count: this.matchCount,
+                index: Math.max(this.matchIndex, 0) + 1,
+            });
+    }
+    get tabKey() {
+        return spokenChord('tab-focus', onApple());
+    }
+    nameInput() {
+        const element = this.renderer?.input?.();
+        if (!element) {
+            return;
+        }
+        if (this.inputWas?.element !== element) {
+            this.restoreInput();
+            this.inputWas = {
+                element,
+                values: Object.fromEntries(['aria-description', 'aria-keyshortcuts', 'aria-label'].map((name) => [
+                    name,
+                    element.getAttribute(name),
+                ])),
+            };
+        }
+        const apple = onApple();
+        const keys = ['find', 'copy', 'tab-focus']
+            .filter((shortcut) => this.takes(shortcut))
+            .map((shortcut) => spokenChord(shortcut, apple))
+            .filter((chord) => chord !== '');
+        element.setAttribute('aria-label', this.inputLabel);
+        element.setAttribute('aria-description', formatWords(this, 'tabHintLabel', { key: this.tabKey }));
+        element.setAttribute('aria-keyshortcuts', keys.join(' '));
+    }
+    restoreInput() {
+        const was = this.inputWas;
+        if (!was) {
+            return;
+        }
+        for (const [name, value] of Object.entries(was.values)) {
+            if (value === null) {
+                was.element.removeAttribute(name);
+            }
+            else {
+                was.element.setAttribute(name, value);
+            }
+        }
+        this.inputWas = undefined;
+    }
+    release() {
+        this.restoreInput();
+        this.findOpen = false;
+        this.matchCount = undefined;
+        this.anySelected = false;
+    }
+    takes(shortcut) {
+        const renderer = this.renderer;
+        if (!renderer) {
+            return false;
+        }
+        if (shortcut === 'find') {
+            return renderer.find !== undefined;
+        }
+        if (shortcut === 'copy') {
+            return renderer.selection !== undefined;
+        }
+        return true;
+    }
+    async openFind() {
+        this.findOpen = true;
+        await this.updateComplete;
+        const field = this.partNamed('find-field');
+        field?.focus();
+        field?.select();
+        if (this.query !== '') {
+            this.search(false, true);
+        }
+    }
+    closeFind() {
+        this.findOpen = false;
+        this.matchCount = undefined;
+        this.matchIndex = -1;
+        this.renderer?.findEnd?.();
+        this.focus();
+    }
+    search(backward, incremental = false) {
+        if (this.query === '') {
+            this.matchCount = undefined;
+            this.renderer?.findEnd?.();
+            return;
+        }
+        this.renderer?.find?.(this.query, { backward, incremental });
+    }
+    async copySelection() {
+        const text = this.renderer?.selection?.() ?? '';
+        if (text !== '' && (await this.copier.copy(text))) {
+            this.say(this.copiedLabel);
+        }
+    }
+    willUpdate(changed) {
+        super.willUpdate(changed);
+        if (this.hasUpdated && changed.has('exitCode') && this.exitCode !== undefined) {
+            this.say(formatWords(this, 'exitedLabel', { code: String(this.exitCode) }));
+        }
+    }
+    updated(changed) {
+        super.updated(changed);
+        const exited = this.exitCode !== undefined;
+        this.toggleState('exited', exited);
+        this.toggleState('find-open', this.findOpen);
+        this.toggleState('tab-moves-focus', this.tabMovesFocus);
+        if (this.renderer &&
+            (changed.has('columns') ||
+                changed.has('rows') ||
+                changed.has('readOnly') ||
+                changed.has('exitCode') ||
+                changed.has('screenReaderMode'))) {
+            this.renderer.settings?.(this.settings);
+        }
+        if (this.renderer && (changed.has('inputLabel') || changed.has('tabHintLabel'))) {
+            this.nameInput();
+        }
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.addEventListener('keydown', this.handleKeys, { capture: true });
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.removeEventListener('keydown', this.handleKeys, { capture: true });
+        clearTimeout(this.ringing);
+    }
+    get drawsAny() {
+        return ['find', 'copy', 'clear', 'fullscreen'].some((control) => this.draws(control));
+    }
+    renderControls() {
+        const toolbar = this.tag('toolbar');
+        const button = this.tag('icon-button');
+        return html `<${toolbar} part="controls" exportparts="toolbar: controls-toolbar" label=${this.controlsLabel}>
+      <slot name="actions" part="actions" @slotchange=${this.handleActions}></slot>
+      ${this.draws('find')
+            ? html `<${button}
+              part="find"
+              exportparts="button: find-button, live: find-live, spinner: find-spinner, text: find-text"
+              .expanded=${this.findOpen}
+              label=${this.findLabel}
+              @click=${() => (this.findOpen ? this.closeFind() : void this.openFind())}
+              @helix-press=${stopPress}
+            >
+              <slot name="find-icon">${drawIcon(magnifyingGlass)}</slot>
+            </${button}>`
+            : nothing}
+      ${this.draws('copy')
+            ? html `<${button}
+              part="copy"
+              exportparts="button: copy-button, live: copy-live, spinner: copy-spinner, text: copy-text"
+              ?disabled=${!this.anySelected}
+              label=${this.copyLabel}
+              @click=${() => void this.copySelection()}
+              @helix-press=${stopPress}
+            >
+              <slot name="copy-icon">${drawIcon(copy)}</slot>
+            </${button}>`
+            : nothing}
+      ${this.draws('clear')
+            ? html `<${button}
+              part="clear"
+              exportparts="button: clear-button, live: clear-live, spinner: clear-spinner, text: clear-text"
+              label=${this.clearLabel}
+              @click=${() => this.clear()}
+              @helix-press=${stopPress}
+            >
+              <slot name="clear-icon">${drawIcon(broom)}</slot>
+            </${button}>`
+            : nothing}
+      ${this.draws('fullscreen')
+            ? html `<${button}
+              part="fullscreen"
+              exportparts="button: fullscreen-button, live: fullscreen-live, spinner: fullscreen-spinner, text: fullscreen-text"
+              aria-pressed=${this.filled ? 'true' : 'false'}
+              label=${this.fullscreenLabel}
+              @click=${() => void this.fullscreen.toggle()}
+              @helix-press=${stopPress}
+            >
+              <slot name="fullscreen-icon">${drawIcon(cornersOut)}</slot>
+            </${button}>`
+            : nothing}
+    </${toolbar}>`;
+    }
+    renderFind() {
+        if (!this.draws('find')) {
+            return nothing;
+        }
+        const toolbar = this.tag('toolbar');
+        const button = this.tag('icon-button');
+        return html `<div part="find-bar" role="search" aria-label=${this.findLabel} ?hidden=${!this.findOpen}>
+      <input
+        part="find-field"
+        aria-label=${this.findLabel}
+        autocomplete="off"
+        placeholder=${this.findLabel}
+        spellcheck="false"
+        type="search"
+        .value=${live(this.query)}
+        @input=${this.handleFindInput}
+        @keydown=${this.handleFindKeys}
+      />
+      <span part="find-count" aria-hidden="true">${this.countText}</span>
+      <${toolbar} part="find-controls" exportparts="toolbar: find-controls-toolbar" label=${this.findControlsLabel}>
+        <slot name="find-actions" part="find-actions"></slot>
+        <${button}
+          part="find-previous"
+          exportparts="button: find-previous-button, live: find-previous-live, spinner: find-previous-spinner, text: find-previous-text"
+          ?disabled=${!this.matchCount}
+          label=${this.findPreviousLabel}
+          @click=${() => this.search(true)}
+          @helix-press=${stopPress}
+        >
+          <slot name="find-previous-icon">${drawIcon(caretUp)}</slot>
+        </${button}>
+        <${button}
+          part="find-next"
+          exportparts="button: find-next-button, live: find-next-live, spinner: find-next-spinner, text: find-next-text"
+          ?disabled=${!this.matchCount}
+          label=${this.findNextLabel}
+          @click=${() => this.search(false)}
+          @helix-press=${stopPress}
+        >
+          <slot name="find-next-icon">${drawIcon(caretDown)}</slot>
+        </${button}>
+        <${button}
+          part="find-close"
+          exportparts="button: find-close-button, live: find-close-live, spinner: find-close-spinner, text: find-close-text"
+          label=${this.findCloseLabel}
+          @click=${() => this.closeFind()}
+          @helix-press=${stopPress}
+        >
+          <slot name="find-close-icon">${drawIcon(x)}</slot>
+        </${button}>
+      </${toolbar}>
+    </div>`;
+    }
+    renderLook() {
+        return html `<span data-look hidden aria-hidden="true" style="color: transparent">
+      <span data-color="active-match" style="color: var(--terminal-active-match-background-color)"></span>
+      <span data-color="active-match-border" style="color: var(--terminal-active-match-border-color)"></span>
+      <span data-color="background" style="color: var(--terminal-background-color)"></span>
+      <span data-color="cursor" style="color: var(--terminal-cursor-color)"></span>
+      <span data-color="foreground" style="color: var(--terminal-color)"></span>
+      <span data-color="match" style="color: var(--terminal-match-background-color)"></span>
+      <span data-color="scrollbar" style="color: var(--terminal-scrollbar-thumb-color)"></span>
+      <span data-color="selection" style="color: var(--terminal-selection-background-color)"></span>
+      ${ANSI.map((name) => html `<span data-color=${name} style="color: var(--terminal-ansi-${name})"></span>`)}
+      ${ANSI.map((name) => html `<span data-color=${`bright-${name}`} style="color: var(--terminal-ansi-bright-${name})"></span>`)}
+    </span>`;
+    }
+    renderStatus() {
+        const exited = this.exitCode !== undefined;
+        const button = this.tag('button');
+        return html `<div part="status" ?hidden=${!exited && !this.tabMovesFocus}>
+      ${exited
+            ? html `<span>${formatWords(this, 'exitedLabel', { code: String(this.exitCode ?? 0) })}</span>
+              <${button}
+                part="restart"
+                exportparts="button: restart-button, live: restart-live, spinner: restart-spinner, text: restart-text"
+                @click=${this.handleRestart}
+                @helix-press=${stopPress}
+              >
+                <slot name="restart-icon" slot="start">${drawIcon(arrowClockwise)}</slot>
+                ${this.restartLabel}
+              </${button}>
+              <slot name="exit-actions" part="exit-actions"></slot>`
+            : nothing}
+      ${this.tabMovesFocus ? html `<span>${formatWords(this, 'tabMovesFocusLabel', { key: this.tabKey })}</span>` : nothing}
+    </div>`;
+    }
+    render() {
+        const headed = this.label !== '' || this.hasLabel || this.hasActions || this.drawsAny;
+        return html `<div
+      part="region"
+      role="group"
+      aria-label=${this.label || this.getAttribute('aria-label') || this.fallbackLabel}
+    >
+      <div part="header" ?hidden=${!headed}>
+        <slot name="label" part="label" @slotchange=${this.handleLabel}>${this.label}</slot>
+        ${this.renderControls()}
+      </div>
+      ${this.renderFind()}
+      <div part="viewport"><slot></slot></div>
+      ${this.renderStatus()}
+      <span part="live" role="status">${keyed(this.said, this.announcement)}</span>
+    </div>
+    ${this.renderLook()}`;
+    }
+};
+__decorate([
+    words,
+    property({ attribute: 'clear-label' })
+], HelixHeadlessTerminal.prototype, "clearLabel", void 0);
+__decorate([
+    property({ converter: numberConverter('columns', undefined) })
+], HelixHeadlessTerminal.prototype, "columns", void 0);
+__decorate([
+    property({ reflect: true })
+], HelixHeadlessTerminal.prototype, "controls", void 0);
+__decorate([
+    words,
+    property({ attribute: 'controls-label' })
+], HelixHeadlessTerminal.prototype, "controlsLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'copied-label' })
+], HelixHeadlessTerminal.prototype, "copiedLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'copy-label' })
+], HelixHeadlessTerminal.prototype, "copyLabel", void 0);
+__decorate([
+    property({ attribute: 'exit-code', converter: numberConverter('exit-code', undefined) })
+], HelixHeadlessTerminal.prototype, "exitCode", void 0);
+__decorate([
+    words,
+    property({ attribute: 'exited-label' })
+], HelixHeadlessTerminal.prototype, "exitedLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'fallback-label' })
+], HelixHeadlessTerminal.prototype, "fallbackLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'find-close-label' })
+], HelixHeadlessTerminal.prototype, "findCloseLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'find-controls-label' })
+], HelixHeadlessTerminal.prototype, "findControlsLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'find-label' })
+], HelixHeadlessTerminal.prototype, "findLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'find-next-label' })
+], HelixHeadlessTerminal.prototype, "findNextLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'find-previous-label' })
+], HelixHeadlessTerminal.prototype, "findPreviousLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'fullscreen-label' })
+], HelixHeadlessTerminal.prototype, "fullscreenLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'input-label' })
+], HelixHeadlessTerminal.prototype, "inputLabel", void 0);
+__decorate([
+    property()
+], HelixHeadlessTerminal.prototype, "label", void 0);
+__decorate([
+    words,
+    property({ attribute: 'matches-label' })
+], HelixHeadlessTerminal.prototype, "matchesLabel", void 0);
+__decorate([
+    property({ attribute: 'readonly', type: Boolean })
+], HelixHeadlessTerminal.prototype, "readOnly", void 0);
+__decorate([
+    words,
+    property({ attribute: 'restart-label' })
+], HelixHeadlessTerminal.prototype, "restartLabel", void 0);
+__decorate([
+    property({ converter: numberConverter('rows', undefined) })
+], HelixHeadlessTerminal.prototype, "rows", void 0);
+__decorate([
+    property({ attribute: 'screen-reader-mode', type: Boolean })
+], HelixHeadlessTerminal.prototype, "screenReaderMode", void 0);
+__decorate([
+    words,
+    property({ attribute: 'tab-hint-label' })
+], HelixHeadlessTerminal.prototype, "tabHintLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'tab-moves-focus-label' })
+], HelixHeadlessTerminal.prototype, "tabMovesFocusLabel", void 0);
+__decorate([
+    words,
+    property({ attribute: 'tab-types-label' })
+], HelixHeadlessTerminal.prototype, "tabTypesLabel", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "findOpen", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "query", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "matchIndex", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "matchCount", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "tabMovesFocus", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "anySelected", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "hasActions", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "hasLabel", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "announcement", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "said", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "renderer", void 0);
+__decorate([
+    state()
+], HelixHeadlessTerminal.prototype, "filled", void 0);
+HelixHeadlessTerminal = __decorate([
+    customElement('helix-headless-terminal')
+], HelixHeadlessTerminal);
+export { HelixHeadlessTerminal };