import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraClipboardWriteFailure,LyraClipboardWriteSuccess}from'../../../internal/clipboard.js';import{type ShikiLanguageInput}from'./code-loader.js';import type{LyraCodeBlockCopyAppearance}from'./code-block-shared.js';import type{LyraAnchor,LyraHighlight,TextSelectRect}from'../../viewers/document-viewer/anchors.js';import'../../overlays/skeleton/skeleton.class.js';export interface LyraCodeBlockEventMap{'lr-copy':CustomEvent<LyraClipboardWriteSuccess>;'lr-error':CustomEvent<null>;'lr-copy-error':CustomEvent<LyraClipboardWriteFailure>;'lr-toggle-request':CustomEvent<{collapsed:boolean;}>;'lr-toggle':CustomEvent<{collapsed:boolean;}>;'lr-line-activate':CustomEvent<{line:number;}>;'lr-text-select':CustomEvent<{readonly text:string;readonly anchor:LyraAnchor;readonly rects:readonly TextSelectRect[];}>;}
/**
* `<lr-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 `<lr-markdown>` and
* `<lr-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 `<lr-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
* `<lr-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.
*
* Set a host `aria-label` (or the matching `accessibleLabel` property) to
* override the filename/language-derived name on the internal focusable code
* region. The name is forwarded to the element that owns `role="group"`, not
* left only on the custom-element host across the shadow boundary.
*
* `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.
*
* Adopts the `line-range` slice of this library's shared anchor-target contract:
* `highlights`/`activeHighlightId` paint (and `highlight-lines` additionally marks) per-line
* emphasis in both the shiki and plain-text-fallback rendering paths identically, and
* `scrollToAnchor()` resolves a `line-range` anchor. `activatable-lines` is a separate, purely
* local affordance that turns the (`line-numbers`-gated) gutter into a keyboard-navigable,
* clickable roving-tabindex group emitting `lr-line-activate` — it doesn't require `highlights` to
* be set. If controlled `code` shrinks while a line owns focus, focus follows the clamped
* surviving line through both plain and highlighted DOM replacement; an explicit move to another
* control during the update is never overridden.
*
* @customElement lr-code-block
* @event lr-copy - The raw `code` was written to the clipboard. Frozen detail:
*   `{ ok: true, text }`.
* @event lr-error - Clipboard writing failed; generic no-detail notification.
* @event lr-copy-error - Clipboard writing failed. Frozen detail:
*   `{ ok: false, text, reason, error }`, where `reason` is
*   `'unsupported' | 'denied' | 'failed'`.
* @event lr-toggle-request - Cancelable request emitted before collapse state changes.
*   `detail: { collapsed }` is the proposed next state.
* @event lr-toggle - The collapse/expand header button was activated.
*   `detail: { collapsed }` — same event name and shape convention as
*   `<lr-thinking-panel>`'s own `lr-toggle`.
* @event lr-line-activate - A gutter line number was activated (click, or Enter/Space while
*   focused) while `activatable-lines` is set. `detail: { line }`.
* @event lr-text-select - Fired when a text selection inside the code body ends. `detail: {
*   text, anchor, rects }`; `anchor` is a `line-range` anchor covering the selected lines.
* @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 control, when `copyable`. A composed
*   `<lr-icon-button>` as of 16.0.0: it still owns the accessible name, the activation and the part
*   names, while its background, radius, hover/press mixes, focus ring and hit-area floor now come
*   from `--lr-icon-button-*`. Also carries `copy-button-text` or `copy-button-icon` for the active
*   `copyAppearance`, since a state cannot be selected with `::part(copy-button)[attr]`.
* @csspart copy-button-text - The copy control while `copyAppearance` is `'text'`.
* @csspart copy-button-icon - The copy control while `copyAppearance` is `'icon'`.
* @csspart copy-button__control - The copy control's own native `<button>`, forwarded because the
*   painted surface sits one shadow boundary deeper than `copy-button`.
* @csspart header-actions - The wrapper around the `header-actions` slot, at the trailing end of
*   the header row.
* @slot header-actions - Extra controls for the header row, rendered after the copy control. Their
*   presence alone is enough to render the header.
* @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.
* @csspart line-highlight - A line marked by `highlight-lines` or a `line-range` entry in
*   `highlights`.
* @csspart line-button - A gutter line-number button, only rendered while `activatable-lines` and
*   `line-numbers` are both set.
* @cssprop [--lr-code-block-max-height=none] - Scroll cap applied to `body`. The `max-height`
*   attribute, when set, writes this same property inline on `body` and therefore wins.
* @cssprop [--lr-code-block-font=var(--lr-font-mono)] - Monospace family for the rendered `pre`
*   and `code`.
* @cssprop [--lr-code-block-tab-size=2] - Tab width for the rendered code, applied to `pre`.
* @cssprop [--lr-code-block-language-bg=var(--lr-color-brand-quiet)] - Background of the
*   `language` badge in `[part="header"]`.
* @cssprop [--lr-code-block-language-color=var(--lr-color-brand)] - Text color of the `language`
*   badge.
*   Same default as `--lr-code-editor-tab-size`, so the editable and read-only code surfaces
*   agree; `lr-markdown`/`lr-markdown-core` declare the same token for their own
*   `code-block` part (they are sibling elements, so they cannot inherit this one). Read as a
*   token and never written inline, so a host override survives shiki's own inline `style` on
*   the highlighted `pre`. The default is a `var()` fallback at the point of use rather than a
*   `:host` declaration, so it inherits: set it on the element, a container, or `:root` and it
*   reaches every code surface below. The markdown surface wraps (`white-space: pre-wrap`) while
*   this one does not, so the same value can look different on a wrapped line, where tab stops
*   restart.
* @cssprop [--lr-code-block-active-line-outline-color=var(--lr-color-brand)] - Outline color of
*   the line marked active by `active-highlight-id`. Retints just that outline, leaving every
*   other `--lr-color-brand` surface in the component (header pill, hover states, focus ring)
*   alone. Inherits, so it can also be set on an ancestor or at the theme level.
* @cssprop [--lr-code-block-highlighted-line-bg=var(--lr-color-warning-quiet)] - Background color
*   of a line marked by `highlight-lines` or a `line-range` entry in `highlights`, in both the
*   light and dark-theme (shiki) rendering paths. Retints just that background, leaving every
*   other `--lr-color-warning-quiet` surface alone. Inherits, so it can also be set on an
*   ancestor or at the theme level.
* @cssprop [--lr-theme-scrollbar-width=auto] - Opt-in theme-level scrollbar width honored by
*   `body`; unset, renders identically to before. Set on `:root` or any ancestor to retune every
*   internal scroll container in the library at once. Shared with `lr-code-block-core` (which
*   reuses this stylesheet).
* @cssprop [--lr-theme-scrollbar-gutter=auto] - Opt-in theme-level scrollbar gutter honored by
*   `body`; see `--lr-theme-scrollbar-width`.
* @status stable
* @since 4.0.0
*/
export declare class LyraCodeBlock extends LyraElement<LyraCodeBlockEventMap>{protected static readonly immutableEventDetails:readonly string[];static styles:import("lit").CSSResultGroup[];
/** The raw source text. Removing the attribute renders an empty code block. */
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;
/** Accessible-name override for the internal focusable code region. Maps
*  to the host's `aria-label` attribute and wins over `filename` and
*  `language`-derived defaults. */
accessibleLabel:string|null;
/** 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;
/** How the header's copy control presents itself. `'text'` (the default) is the labelled button
*  this component has always rendered -- unset, nothing about the header changes. `'icon'` swaps
*  the visible label for a compact glyph and promotes the same localized Copy/Copied/failure
*  string to the control's accessible name, for a dense header that already carries a filename,
*  a language chip and slotted `header-actions`. */
copyAppearance:LyraCodeBlockCopyAppearance;
/** Whether a light-DOM child is assigned to `header-actions`. Read from `children` rather than a
*  `slotchange`, because the slot only exists once the header renders -- and whether the header
*  renders at all is exactly what this answers for a code block with no filename, language,
*  copy control or collapse toggle. `headerActionsObserver` closes that loop for a child appended
*  after first render, which no `slotchange` could ever report for a header that isn't there. */
private hasHeaderActions;
/** Watches the host's own light DOM so appending (or removing) a `slot="header-actions"` child
*  brings the header into existence -- or retires it -- without the consumer touching a
*  property. */
private headerActionsObserver?;
/** A CSS length (e.g. `"20rem"`); once set, the code scrolls internally
*  past this height instead of growing the page. */
maxHeight:string;
/** Whether to display one-based line numbers beside the code. Highlighted gutters
*  follow live locale and line-label string changes. */
lineNumbers:boolean;
/** Comma-separated 1-based inclusive line ranges (e.g. `"3-5,7"`) to visually emphasize.
*  Removing the attribute clears these ranges. Declarative sugar over `highlights` — merges with, and renders identically to, any
*  `line-range` entries in `highlights`. */
highlightLines:string;
/** Makes the (`line-numbers`-gated) gutter a roving group of activation buttons. */
activatableLines:boolean;private _highlights;
/** Host-supplied highlights to paint over the code. Only `line-range` anchors are meaningful
*  here — every other `LyraAnchor` kind, and a highlight with a missing, malformed, or
*  non-discriminated anchor, is ignored (`snapshotLyraHighlights`).
* @default [] */
get highlights():readonly LyraHighlight[];set highlights(value:readonly LyraHighlight[]);
/** The `highlights` entry, if any, currently treated as active (`data-active` on its lines). */
activeHighlightId:string|null;
/** Anchor kinds this component resolves via `scrollToAnchor()`. */
readonly anchorKinds:readonly LyraAnchor['kind'][];private focusedLine;private restoreFocusedLineAfterUpdate;
/** 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. For a TypeScript
*  annotation, use `import type { ShikiLanguageInput } from
*  '@aceshooting/lyra-ui/components/conversation/code-block/code-block.js'`;
*  this granular type-only import emits no registration side effect. */
languages?:Readonly<Record<string,ShikiLanguageInput>>;private highlightedHtml;private shikiReady;private justCopied;private copyFailed;private isDarkTheme;private highlighter?;private readonly interactions;private highlightToken;private defaultHighlighterLoading;private readonly bodyId;constructor();connectedCallback():void;private ensureDefaultHighlighter;disconnectedCallback():void;adoptedCallback():void;private preSuppliedGrammar;private lineHighlightSet;private activeHighlightLineSet;private lineCount;
/** Resolves a `line-range` anchor (or a `highlights` id string resolving to one) by scrolling
*  its start line into view within `[part="body"]`. Resolves `false` when the anchor isn't a
*  `line-range`, the id isn't found, or the start line is out of bounds. */
scrollToAnchor(target:LyraAnchor|string):Promise<boolean>;
/** Recomputes Shiki palette selection after an imperative CSSOM theme change. */
refreshTheme():void;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;private syncHeaderActions;private observeHeaderActions;
/** Whether this render shows the loading skeleton instead of the code. */
private showsSkeleton;private syncHighlight;private tokenize;private renderPlainCode;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-code-block':LyraCodeBlock;}}