import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import type{LyraClipboardWriteFailure,LyraClipboardWriteSuccess}from'../../../internal/clipboard.js';import{type ShikiLanguageSource}from'./shiki-types.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 LyraCodeBlockCoreEventMap{'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-core>` — a build-lean variant of `<lr-code-block>` for
* a consumer whose `languages` map already covers every language it will
* ever render. It only ever calls `loadShikiHighlighterCore()` (from the peer-neutral Shiki
* capability leaf) with `languages`' already-resolved entries — never `loadShikiHighlighter()`, the
* default ~200-language dynamic-import table loader `<lr-code-block>` calls. This component's own
* module never textually contains a call to (or import of) `loadShikiHighlighter` at all, so a
* consumer importing this entry point instead of `code-block.js` gets a
* genuinely shiki-full-table-free build.
*
* A `languages` entry may also be a lazy loader (`() => import('@shikijs/langs/<name>')`) instead
* of an already-resolved grammar — resolved and registered into the highlighter (via
* `HighlighterCore.loadLanguage()`) the first time a fence actually requests that key, memoized per
* key so it is never re-imported. See the `languages` property doc for the exact shape.
*
* A `language` value absent from `languages` always renders the plain
* `<pre><code>` fallback — there is no default/full-table highlighter here
* to fall back to, unlike `<lr-code-block>`'s dynamic-import path for an
* unmapped language, and neither does a `languages` entry whose lazy loader rejects. That fallback
* is the *default* rendering path, not a degraded one, same as `<lr-code-block>`'s own plain-text
* fallback.
*
* Everything else — `code`/`language`/`filename`/`copyable`/`collapsible`/
* `collapsed`/`maxHeight`, the copy button, the collapse header toggle, the
* loading-skeleton behavior while the fine-grained highlighter itself
* resolves — matches `<lr-code-block>` exactly. A host `aria-label` (or
* the matching `accessibleLabel` property) is forwarded to the internal
* focusable element that owns the named `group` role.
*
* Adopts the `line-range` slice of this library's shared anchor-target contract, identical to
* `<lr-code-block>`: `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-core
* @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`.
*   Shared with `lr-code-block` (this component reuses its stylesheet), `lr-code-editor`, and
*   the markdown viewers' own `code-block` part, so every code surface agrees on a tab's width.
* @cssprop [--lr-code-block-active-line-outline-color=var(--lr-color-brand)] - Outline color of
*   the line marked active by `active-highlight-id`, leaving every other `--lr-color-brand`
*   surface in the component alone.
* @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`. Shared with
*   `lr-code-block` (this component reuses its stylesheet), leaving every other
*   `--lr-color-warning-quiet` surface alone.
* @cssprop [--lr-code-block-language-bg=var(--lr-color-brand-quiet)] - Background of the
*   `language` badge in `[part="header"]`. Shared with `lr-code-block` (this component reuses its
*   stylesheet).
* @cssprop [--lr-code-block-language-color=var(--lr-color-brand)] - Text color of the `language`
*   badge.
* @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` (this component
*   reuses its 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 LyraCodeBlockCore extends LyraElement<LyraCodeBlockCoreEventMap>{protected static readonly immutableEventDetails:readonly string[];
/** `languages` grammar objects are caller-owned data read only through Shiki's own APIs --
*  bounded, detached, and frozen on assignment like every other public collection, so a later
*  in-place mutation of a caller's grammar object can never silently change what this instance
*  has already handed to `loadShikiHighlighterCore()`. */
protected static readonly ownedCollectionProperties: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 it isn't a key in
*  `languages`, the code renders as plain unhighlighted text — this
*  component has no default/full-table highlighter to fall back to. */
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;
/** Turns the (`line-numbers`-gated) gutter into a roving-tabindex group of buttons emitting
*  `lr-line-activate`. Has no effect while `line-numbers` is unset. */
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;
/** Grammar definitions this instance can highlight, e.g. `{ json: jsonGrammar }` (import from
*  `shiki/langs/<name>.mjs`), or a lazy loader per key, e.g.
*  `{ bash: () => import('@shikijs/langs/bash') }` -- called (at most once per key, memoized)
*  the first time a fenced block actually requests that language, instead of requiring every
*  grammar to already be imported before the map can be bound at all. This component has no
*  default/full-table fallback highlighter -- a `language` absent from this map always renders
*  the plain-text fallback, and so does a key whose loader rejects. Empty (the
*  default) never highlights at all. Replacing the map starts a new loading generation; an
*  older map that settles later cannot clear the current map's loading state or replace its
*  highlighted output. For a TypeScript annotation, use `import type { ShikiLanguageSource } from
*  '@aceshooting/lyra-ui/components/conversation/code-block/code-block-core.js'`; this granular
*  type-only import emits no registration side effect. */
languages:Readonly<Record<string,ShikiLanguageSource>>;private highlightedHtml;private shikiReady;private justCopied;private copyFailed;private isDarkTheme;private readonly interactions;private highlightToken;private highlighterGeneration;private activeLanguages?;private readonly bodyId;constructor();connectedCallback():void;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. Unlike `<lr-code-block>`,
*  the only highlighter this variant ever waits on is the fine-grained one seeded from
*  `languages` -- so a `language` absent from that map has nothing pending and never shows the
*  skeleton. Read by both `updated()` and `render()` so the `aria-busy` host attribute can never
*  disagree with what's on screen. */
private showsSkeleton;private activateLanguages;private syncHighlight;private tokenize;private renderPlainCode;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-code-block-core':LyraCodeBlockCore;}}