@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/citation-badge/citation-badge.js

@@ -1,300 +1,5 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { html, nothing } from 'lit';
-import { property, state, query } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './citation-badge.class.js';
+import { LyraCitationBadge } from './citation-badge.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { place } from '../../internal/positioner.js';
-import { nextId } from '../../internal/a11y.js';
-import { styles } from './citation-badge.styles.js';
-/** Visible (not just color-coded) status word, folded into the computed
- *  accessible name — `''` for `default` omits the status clause entirely
- *  rather than announcing a meaningless "Citation 3, Default". */
-const STATUS_LABEL = {
-    default: '',
-    high: 'High confidence',
-    medium: 'Medium confidence',
-    low: 'Low confidence',
-    verified: 'Verified',
-    unverified: 'Unverified',
-};
-// A short grace period before the popover actually hides on pointer-leave/
-// focus-out, so moving the mouse from the badge into the popover itself (to
-// select/copy its text) doesn't make it vanish mid-move. Cancelled outright
-// if hover or focus returns before it fires. No delay on Escape or explicit
-// keyboard blur — those are intentional dismissals, not transient pointer
-// travel, so they close immediately.
-const HIDE_DELAY_MS = 200;
-/**
- * `<lyra-citation-badge>` — an inline `[n]` citation marker with a hover/
- * focus preview popover and confidence/verification-status coloring. Used
- * for an agent response's inline citations, each carrying a `source-id`
- * that matches a corresponding `<lyra-source-card>` shown elsewhere on the
- * page (a sibling component in this same family — this component doesn't
- * import or know anything about it, only carries the id through its
- * events).
- *
- * The default slot is *not* the badge's visible content — the badge always
- * renders `[index]` — it's reserved for optional rich preview content (e.g.
- * a filename + short excerpt) shown in a floating popover on hover/focus,
- * positioned with `internal/positioner.js`'s `place()` the same way
- * `<lyra-tool-call-chip>` positions its own detail tooltip. No popover shows
- * at all when the slot carries no content, and the popover never traps
- * focus — it's supplementary preview content, not a modal, so Tab continues
- * past the badge normally even while it happens to be visible from a mouse
- * hover.
- *
- * Two distinct signals fire from the same badge: `lyra-citation-activate`
- * (click, or Enter while focused — native `<button>` behavior, no listener
- * needed for the Enter case) is the lightweight "jump to this source"
- * signal a host wires to scrolling/highlighting the matching
- * `<lyra-source-card>`. `lyra-citation-open` (dblclick, or Space while
- * focused) is a distinct "full preview" signal — `href` in its detail is
- * `undefined` when the `href` prop isn't set; the consumer decides what
- * "open" means (a new tab, a dialog, etc). A double-click still fires two
- * `lyra-citation-activate` events (one per constituent click — standard
- * browser `dblclick` behavior) in addition to the one `lyra-citation-open`;
- * a consumer that only cares about the richer signal on a double-click
- * should ignore the paired activate events in that case.
- *
- * Status coloring: `verified`/`high` use the success tones (a claim that's
- * been checked out, or the model is confident in). `medium`/`low` use
- * warning (progressively less certain, but still a real citation).
- * `unverified` uses danger — deliberately distinct from `low`: "hasn't been
- * checked at all" is a different (arguably riskier) claim than "checked but
- * uncertain". `default` renders as plain neutral text with no background
- * tint, for citations that carry no confidence/verification signal at all.
- *
- * @customElement lyra-citation-badge
- * @slot - Rich preview/tooltip content (e.g. a filename + excerpt), shown in
- * a floating popover on hover/focus. Nothing renders (no hover affordance at
- * all) when this slot is empty.
- * @event lyra-citation-activate - The badge was activated (click, or Enter
- * while focused). `detail: { sourceId, index }`.
- * @event lyra-citation-open - The badge's "full preview" affordance was
- * triggered (dblclick, or Space while focused).
- * `detail: { sourceId, index, href }`.
- * @csspart base - The clickable badge (`<button>`).
- * @csspart bracket - Each of the two literal `[`/`]` glyphs.
- * @csspart index - The citation number.
- * @csspart popover - The floating preview panel (only meaningful while open).
- */
-export class LyraCitationBadge extends LyraElement {
-    constructor() {
-        super(...arguments);
-        /** The citation number shown, e.g. `3` renders as `[3]`. */
-        this.index = 1;
-        /** Confidence/verification state — drives the badge's color and (unless
-         *  `label` is set) part of its accessible name. */
-        this.status = 'default';
-        /** Id of a corresponding `<lyra-source-card>` elsewhere on the page —
-         *  echoed back verbatim in both events, never read or validated here. */
-        this.sourceId = '';
-        /** Optional direct link target for the citation's source. Carried into
-         *  `lyra-citation-open`'s detail as-is; this component never navigates. */
-        this.href = '';
-        /** Overrides the computed accessible name (`"Citation {index}[, {status}]"`). */
-        this.label = '';
-        // A `[part]` always contains a literal `<slot>` child regardless of
-        // assigned content, so `:empty` never matches — real emptiness is tracked
-        // in JS instead, same fix lyra-tool-call-chip's hasDetailSlot/lyra-stat's
-        // hasIcon etc. already establish.
-        this.hasPreviewSlot = false;
-        this.popoverOpen = false;
-        this.popoverId = nextId('citation-badge-popover');
-        // Hover and focus are tracked as independent "keep it open" reasons —
-        // mirrors lyra-toast-item's identical hovering/focused pair — so releasing
-        // one (e.g. the pointer leaving while the badge still has keyboard focus)
-        // doesn't schedule a hide the other modality is still holding open.
-        this.hovering = false;
-        this.focused = false;
-        this.onSlotChange = (e) => {
-            this.hasPreviewSlot = e.target.assignedElements({ flatten: true }).length > 0;
-            // The slot can be emptied out from under an already-open popover (e.g. a
-            // consumer clearing preview content asynchronously) — nothing left to
-            // show, so don't leave an empty panel floating open.
-            if (!this.hasPreviewSlot)
-                this.hidePreviewNow();
-        };
-        // Attached to the wrapper (not the button alone) so the popover's own
-        // slotted content counts too — pointerenter/pointerleave/focusin/focusout
-        // fire relative to whichever element they're bound to, not per descendant,
-        // so moving the pointer or focus between the button and the popover panel
-        // within this same wrapper never toggles hovering/focused off and on.
-        this.onPointerEnter = () => {
-            this.hovering = true;
-            this.showPreview();
-        };
-        this.onPointerLeave = () => {
-            this.hovering = false;
-            this.scheduleHidePreview();
-        };
-        this.onFocusIn = () => {
-            this.focused = true;
-            this.showPreview();
-        };
-        // No grace period here, unlike onPointerLeave -- a blur (Tab/Shift+Tab
-        // away, or focus programmatically moved elsewhere) is a deliberate
-        // navigation, not the transient pointer travel the delay exists to survive,
-        // so it closes at once. Still deferred to hover if the pointer happens to
-        // be resting on the badge/popover at the same time.
-        this.onFocusOut = () => {
-            this.focused = false;
-            if (this.hovering)
-                return;
-            this.hidePreviewNow();
-        };
-        // keydown bubbles up from whatever actually holds focus (the button, or a
-        // focusable element inside slotted preview content) — attaching this at
-        // the wrapper, rather than the button alone, is what makes Escape work
-        // "while the popover has focus-within" per the component's contract,
-        // without needing to track focus targets explicitly here.
-        this.onKeyDown = (e) => {
-            if (e.key === 'Escape' && this.popoverOpen) {
-                // Swallow it here rather than letting it bubble to e.g. a containing
-                // lyra-dialog's own Escape-to-close handler — dismissing this
-                // lightweight preview shouldn't also close a surrounding modal.
-                e.stopPropagation();
-                this.hidePreviewNow();
-                return;
-            }
-            // Space normally activates a <button> the same as Enter, but this
-            // component gives the two keys distinct meanings (Enter = activate,
-            // Space = open) — so Space's native click-on-keyup must be pre-empted
-            // here (preventDefault on keydown suppresses it) rather than left to
-            // fire alongside this. Enter deliberately gets no such handling: its
-            // native immediate click already reaches onClick below.
-            if (e.key === ' ' && !e.repeat && e.target === this.buttonEl) {
-                e.preventDefault();
-                this.emitOpen();
-            }
-        };
-        this.onClick = () => {
-            this.emit('lyra-citation-activate', { sourceId: this.sourceId, index: this.index });
-        };
-        this.onDblClick = () => {
-            this.emitOpen();
-        };
-    }
-    static { this.styles = [LyraElement.styles, styles]; }
-    willUpdate() {
-        if (!this.hasUpdated) {
-            this.hasPreviewSlot = Array.from(this.children).some((el) => !el.hasAttribute('slot'));
-        }
-    }
-    updated(changed) {
-        if (changed.has('popoverOpen')) {
-            this.cleanupPositioner?.();
-            this.cleanupPositioner = undefined;
-            if (this.popoverOpen && this.buttonEl && this.popoverEl) {
-                this.cleanupPositioner = place(this.buttonEl, this.popoverEl, { placement: 'top-start' });
-            }
-        }
-    }
-    disconnectedCallback() {
-        super.disconnectedCallback();
-        this.cleanupPositioner?.();
-        clearTimeout(this.hideTimer);
-    }
-    get accessibleLabel() {
-        if (this.label)
-            return this.label;
-        const statusText = STATUS_LABEL[this.status];
-        return statusText ? `Citation ${this.index}, ${statusText}` : `Citation ${this.index}`;
-    }
-    // Named showPreview/hidePreviewNow (not show/hidePopover) to avoid
-    // colliding with the standard HTML Popover API's own
-    // HTMLElement.prototype.showPopover()/hidePopover() -- this component
-    // renders its own floating panel via internal/positioner.js rather than
-    // the native `popover` attribute, but TS's DOM lib still declares those
-    // method names on every HTMLElement subclass, so reusing them here would
-    // be a same-name-different-signature override error.
-    showPreview() {
-        if (!this.hasPreviewSlot || this.popoverOpen)
-            return;
-        clearTimeout(this.hideTimer);
-        this.hideTimer = undefined;
-        this.popoverOpen = true;
-    }
-    scheduleHidePreview() {
-        if (!this.popoverOpen || this.hovering || this.focused)
-            return;
-        clearTimeout(this.hideTimer);
-        this.hideTimer = setTimeout(() => {
-            this.hideTimer = undefined;
-            this.popoverOpen = false;
-        }, HIDE_DELAY_MS);
-    }
-    hidePreviewNow() {
-        clearTimeout(this.hideTimer);
-        this.hideTimer = undefined;
-        if (this.popoverOpen)
-            this.popoverOpen = false;
-    }
-    emitOpen() {
-        this.emit('lyra-citation-open', {
-            sourceId: this.sourceId,
-            index: this.index,
-            href: this.href || undefined,
-        });
-    }
-    render() {
-        return html `
-      <span
-        class="wrapper"
-        @pointerenter=${this.onPointerEnter}
-        @pointerleave=${this.onPointerLeave}
-        @focusin=${this.onFocusIn}
-        @focusout=${this.onFocusOut}
-        @keydown=${this.onKeyDown}
-      >
-        <button
-          part="base"
-          type="button"
-          aria-label=${this.getAttribute('aria-label') || this.accessibleLabel}
-          aria-describedby=${this.hasPreviewSlot && this.popoverOpen ? this.popoverId : nothing}
-          @click=${this.onClick}
-          @dblclick=${this.onDblClick}
-        >
-          <span part="bracket" aria-hidden="true">[</span><span part="index">${this.index}</span
-          ><span part="bracket" aria-hidden="true">]</span>
-        </button>
-        <div part="popover" id=${this.popoverId} role="tooltip" ?hidden=${!this.popoverOpen}>
-          <slot @slotchange=${this.onSlotChange}></slot>
-        </div>
-      </span>
-    `;
-    }
-}
-__decorate([
-    property({ type: Number })
-], LyraCitationBadge.prototype, "index", void 0);
-__decorate([
-    property({ reflect: true })
-], LyraCitationBadge.prototype, "status", void 0);
-__decorate([
-    property({ attribute: 'source-id' })
-], LyraCitationBadge.prototype, "sourceId", void 0);
-__decorate([
-    property()
-], LyraCitationBadge.prototype, "href", void 0);
-__decorate([
-    property()
-], LyraCitationBadge.prototype, "label", void 0);
-__decorate([
-    state()
-], LyraCitationBadge.prototype, "hasPreviewSlot", void 0);
-__decorate([
-    state()
-], LyraCitationBadge.prototype, "popoverOpen", void 0);
-__decorate([
-    query('[part="base"]')
-], LyraCitationBadge.prototype, "buttonEl", void 0);
-__decorate([
-    query('[part="popover"]')
-], LyraCitationBadge.prototype, "popoverEl", void 0);
 defineElement('citation-badge', LyraCitationBadge);
+//# sourceMappingURL=citation-badge.js.map

package/dist/components/citation-badge/citation-badge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"citation-badge.js","sourceRoot":"","sources":["../../../src/components/citation-badge/citation-badge.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,aAAa,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC"}

package/dist/components/citation-badge/citation-badge.styles.d.ts

@@ -1 +1,2 @@
 export declare const styles: import("lit").CSSResult;
+//# sourceMappingURL=citation-badge.styles.d.ts.map

package/dist/components/citation-badge/citation-badge.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"citation-badge.styles.d.ts","sourceRoot":"","sources":["../../../src/components/citation-badge/citation-badge.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,yBA8FlB,CAAC"}

package/dist/components/citation-badge/citation-badge.styles.js

@@ -3,7 +3,7 @@ export const styles = css `
   :host {
     display: inline-flex;
     vertical-align: baseline;
-    line-height: 1;
+    line-height: var(--lyra-line-height-none);
     /* Per-status accent -- one pair of custom properties swapped by the
        :host([status]) rules below rather than repeating background/color
        per part per status. 'default' (and any unrecognized status) stays
@@ -40,16 +40,16 @@ export const styles = css `
     display: inline-flex;
     align-items: baseline;
     box-sizing: border-box;
-    padding: 0 0.3em;
-    border: 1px solid var(--lyra-citation-badge-border);
+    padding: 0 var(--lyra-size-0-3em);
+    border: var(--lyra-border-width-thin) solid var(--lyra-citation-badge-border);
     border-radius: calc(var(--lyra-radius) * 0.6);
     background: var(--lyra-citation-badge-bg);
     color: var(--lyra-citation-badge-accent);
     font: inherit;
-    font-size: 0.75em;
-    font-weight: 600;
+    font-size: var(--lyra-size-0-75em);
+    font-weight: var(--lyra-font-weight-semibold);
     font-variant-numeric: tabular-nums;
-    line-height: 1.5;
+    line-height: var(--lyra-line-height-normal);
     cursor: pointer;
     -webkit-tap-highlight-color: transparent;
     transition:
@@ -75,16 +75,16 @@ export const styles = css `
      chase a fade. */
   [part='popover'] {
     position: fixed;
-    z-index: 900;
+    z-index: var(--lyra-layer-dropdown);
     box-sizing: border-box;
-    max-inline-size: min(90vw, 22rem);
+    max-inline-size: min(90vw, var(--lyra-size-22rem));
     padding: var(--lyra-space-s) var(--lyra-space-m);
     background: var(--lyra-color-surface);
-    border: 1px solid var(--lyra-color-border);
+    border: var(--lyra-border-width-thin) solid var(--lyra-color-border);
     border-radius: var(--lyra-radius);
     box-shadow: var(--lyra-shadow);
-    font-size: 0.8125rem;
-    line-height: 1.4;
+    font-size: var(--lyra-font-size-sm);
+    line-height: var(--lyra-line-height-1-4);
     color: var(--lyra-color-text);
   }
 
@@ -94,3 +94,4 @@ export const styles = css `
     }
   }
 `;
+//# sourceMappingURL=citation-badge.styles.js.map

package/dist/components/citation-badge/citation-badge.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"citation-badge.styles.js","sourceRoot":"","sources":["../../../src/components/citation-badge/citation-badge.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8FxB,CAAC"}

package/dist/components/code-block/code-block.class.d.ts

@@ -0,0 +1,141 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { type ShikiLanguageInput } from './code-loader.js';
+import '../skeleton/skeleton.class.js';
+/**
+ * `<lyra-code-block>` — fenced code display with optional lazy syntax
+ * highlighting and a copy button. No highlighting grammar ships in this
+ * component itself: it lazy-loads the optional peer dependency `shiki` (see
+ * `code-loader.ts`) for the actual tokenizing, and degrades to a plain
+ * `<pre><code>` when that peer isn't installed or `language` is unset/
+ * unrecognized — the exact same optional-peer shape `<lyra-markdown>` and
+ * `<lyra-chart>` already establish. That fallback is the *default* rendering
+ * path, not a degraded one: unhighlighted code is perfectly usable, and it's
+ * what every instance renders at zero extra bytes until shiki resolves.
+ *
+ * A `<lyra-skeleton>` placeholder stands in only while shiki itself is
+ * loading for the very first time on the page (cached — see
+ * `loadShikiHighlighter()`) and `language` is set. It's deliberately *not*
+ * shown again for a subsequent per-language grammar load (e.g. a second
+ * `<lyra-code-block>` requesting a language no earlier instance has used
+ * yet) — that grammar fetch is typically fast, and the plain-text fallback
+ * is already a perfectly readable placeholder for it, so a second
+ * loading-chrome state would add complexity for little practical benefit.
+ *
+ * `languages` is an additive, opt-in escape hatch from that default path for
+ * a consumer whose language set is fixed and known ahead of time: a map of
+ * language id to an already-imported shiki grammar module (e.g. `import bash
+ * from 'shiki/langs/bash.mjs'`). When `language` matches a key in `languages`,
+ * this component seeds a fine-grained `createHighlighterCore()` highlighter
+ * with *only* the pre-supplied grammars (see `code-loader.ts`'s
+ * `loadShikiHighlighterCore()`) instead of waiting on `loadShikiHighlighter()`
+ * and its dynamic per-language `loadLanguage()` import. The payoff isn't
+ * runtime cost — the default dynamic-import path is already well-optimized
+ * for that — it's *build output*: shiki's main entry point bundles a dynamic
+ * `import()` per bundled language (~200 of them) because a bundler can't
+ * statically narrow which of those a `loadLanguage(lang: string)` call might
+ * request at runtime, so it conservatively emits a build-output chunk for
+ * every one of them. `shiki/core`'s fine-grained API has no such table — a
+ * bundler only ever sees the exact grammar modules `languages` itself
+ * `import`s, so a consumer who pins its full language set this way trades a
+ * hand-maintained list for a build output scoped to just those languages
+ * instead of shiki's entire bundled set. A language requested but absent
+ * from `languages` still falls back to the ordinary dynamic-import path
+ * unchanged, so this is a partial opt-in, not a replacement for it.
+ *
+ * @customElement lyra-code-block
+ * @event lyra-copy - The copy button was activated. `detail: { text }` is
+ *   always the raw `code` value (never the highlighted HTML), and always
+ *   fires regardless of whether the actual OS clipboard write succeeded —
+ *   same convention as `<lyra-json-viewer>`'s own copy button.
+ * @event lyra-toggle - The collapse/expand header button was activated.
+ *   `detail: { collapsed }` — same event name and shape convention as
+ *   `<lyra-thinking-panel>`'s own `lyra-toggle`.
+ * @csspart base - The outer container.
+ * @csspart header - The row above the code (filename/language/copy/toggle),
+ *   present whenever there's anything to put in it.
+ * @csspart filename - The `filename` text, when set.
+ * @csspart language - The `language` badge, when set, so the language is
+ *   exposed to assistive tech as visible text rather than only a `language`
+ *   attribute a screen reader would never announce.
+ * @csspart copy-button - The copy-to-clipboard button, when `copyable`.
+ * @csspart toggle - The collapse/expand chevron button, when `collapsible`.
+ * @csspart body - The scrollable region wrapping the code (or the loading
+ *   skeleton); respects `max-height`, `hidden` while `collapsible` and
+ *   `collapsed`.
+ * @csspart pre - The rendered `<pre>` — shiki's own in the highlighted path,
+ *   this component's own plain one in the fallback path.
+ * @csspart code - The rendered `<code>`, same split as `pre` above.
+ */
+export interface LyraCodeBlockEventMap {
+    'lyra-copy': CustomEvent<{
+        text: string;
+    }>;
+}
+export declare class LyraCodeBlock extends LyraElement<LyraCodeBlockEventMap> {
+    static styles: import("lit").CSSResultGroup[];
+    /** The raw source text. */
+    code: string;
+    /** A shiki-recognized language id or alias (e.g. `"javascript"`,
+     *  `"python"`, `"json"`). When unset, or when shiki doesn't recognize it,
+     *  the code renders as plain unhighlighted text regardless of whether
+     *  shiki itself is available. */
+    language: string;
+    /** Shown in the header above the code, when set. */
+    filename: string;
+    /** Whether the code region can be collapsed via a header toggle. */
+    collapsible: boolean;
+    /** Whether the code region is currently hidden. Only has a visible effect
+     *  while `collapsible` is also true. */
+    collapsed: boolean;
+    /** Shows a copy-to-clipboard button in the header. */
+    copyable: boolean;
+    /** A CSS length (e.g. `"20rem"`); once set, the code scrolls internally
+     *  past this height instead of growing the page. */
+    maxHeight: string;
+    /** A map of language id to an already-imported shiki grammar module's
+     *  default export (e.g. `{ bash: bashGrammar }` where `bashGrammar` came
+     *  from a module-scope `import bash from 'shiki/langs/bash.mjs'`). When
+     *  `language` matches a key here, highlighting for it is seeded from
+     *  exactly this pre-supplied grammar via a fine-grained
+     *  `createHighlighterCore()` highlighter, bypassing the default
+     *  `loadShikiHighlighter()` singleton and its dynamic per-language
+     *  `loadLanguage()` import entirely for that language — see the class doc
+     *  above for the build-output rationale. A `language` value absent from
+     *  this map (or left unset, or when `languages` itself is unset) falls
+     *  back to that default dynamic-import path unchanged. */
+    languages?: Record<string, ShikiLanguageInput>;
+    /** When `true`, skips the default `loadShikiHighlighter()` call in `connectedCallback()`
+     *  entirely — for a consumer whose `languages` map already covers every language every instance
+     *  will ever render, so the bundler has no reachable path from this component to shiki's
+     *  ~200-language dynamic-import table. A `language` value absent from `languages` while this is
+     *  `true` renders the plain-text fallback (no attempt to fall back to the now-unloaded default
+     *  highlighter) rather than hanging. `false` (the default) reproduces today's unconditional
+     *  `loadShikiHighlighter()` call exactly. */
+    languagesOnly: boolean;
+    private highlightedHtml;
+    private shikiReady;
+    private justCopied;
+    private highlighter?;
+    private highlightToken;
+    private copyTimeoutId?;
+    private readonly bodyId;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private preSuppliedGrammar;
+    protected willUpdate(changed: PropertyValues): void;
+    protected updated(): void;
+    private syncHighlight;
+    private tokenize;
+    private writeClipboard;
+    private copy;
+    private toggleCollapsed;
+    private renderHeader;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-code-block': LyraCodeBlock;
+    }
+}
+//# sourceMappingURL=code-block.class.d.ts.map

package/dist/components/code-block/code-block.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-block.class.d.ts","sourceRoot":"","sources":["../../../src/components/code-block/code-block.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAG9E,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAI7D,OAAO,EAOL,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,+BAA+B,CAAC;AA4BvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,WAAW,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5C;AACD,qBAAa,aAAc,SAAQ,WAAW,CAAC,qBAAqB,CAAC;IACnE,MAAM,CAAC,MAAM,iCAAgC;IAE7C,2BAA2B;IACf,IAAI,SAAM;IAEtB;;;qCAGiC;IACrB,QAAQ,SAAM;IAE1B,oDAAoD;IACxC,QAAQ,SAAM;IAE1B,oEAAoE;IACxB,WAAW,UAAS;IAEhE;4CACwC;IACI,SAAS,UAAS;IAE9D,sDAAsD;IACV,QAAQ,UAAQ;IAE5D;wDACoD;IACb,SAAS,SAAM;IAEtD;;;;;;;;;;8DAU0D;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAE/E;;;;;;iDAM6C;IACa,aAAa,UAAS;IAMvE,OAAO,CAAC,eAAe,CAAuB;IAK9C,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,UAAU,CAAS;IAEpC,OAAO,CAAC,WAAW,CAAC,CAA0B;IAK9C,OAAO,CAAC,cAAc,CAAK;IAE3B,OAAO,CAAC,aAAa,CAAC,CAAgC;IAEtD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IAEpD,iBAAiB,IAAI,IAAI,CAQxB;IAED,oBAAoB,IAAI,IAAI,CAG3B;IAMD,OAAO,CAAC,kBAAkB;IAS1B,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAWlD;IAED,SAAS,CAAC,OAAO,IAAI,IAAI,CAOxB;IAED,OAAO,CAAC,aAAa;IA6CrB,OAAO,CAAC,QAAQ;IAoBhB,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,IAAI,CAQV;IAEF,OAAO,CAAC,eAAe,CAGrB;IAEF,OAAO,CAAC,YAAY;IA4CpB,MAAM,IAAI,cAAc,CA2BvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,iBAAiB,EAAE,aAAa,CAAC;KAClC;CACF"}