lintje 0.1.1

package/dist-elements/types/components/tables/list/list.d.ts

@@ -0,0 +1,123 @@
+/**
+ * `<lintje-list>` — rows for what needs no columns: title, a muted line, a fact or actions. It is
+ * also the work list: what someone made or had made, in progress or done, with the kind as an
+ * icon, the state as a word, the progress as a bar, and rows grouped under a moment ("Vandaag").
+ * A row's title is one line, cut with an ellipsis; it wraps where no pointer shows its tooltip:
+ * below 768 px, without hover, and under the keyboard's focus. A run's moment is a heading at
+ * `heading-level`.
+ *
+ * The whole row is clickable but the title is the one tab stop; a row with `clickable: false` opens
+ * nothing, and its title is plain text or, with an `href`, only a link. It does not navigate: a plain
+ * click is cancelled and sent as `lintje-row-click`; a modifier click on a title link is the
+ * browser's. A menu's `lintje-action` is stopped and sent again with its row. When the focused
+ * control leaves with an update (a row removed, an action replaced), the focus goes to the same
+ * row's other control, else the next row, the previous one, or the list itself. A rename that ends
+ * gives the focus to its row's first control, found by its id or, saved under a new one, its place.
+ *
+ * A row with `rename` turns its title into a field in place, with its save and cancel: renaming
+ * needs no dialog. The host keeps the state, as it does for every row.
+ *
+ * Events: `lintje-row-click` `{ id, label, href? }`, `lintje-row-action` `{ id, label, value }`
+ * (every chosen menu row, a link row included, and the row's own `action`), `lintje-navigate` `{ href }` (from a link row in a
+ * menu, after its `lintje-row-action`), `lintje-row-rename` `{ id, value }` and
+ * `lintje-row-rename-cancel` `{ id }` (Enter and Escape too).
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../feedback/empty-state/empty-state.js';
+import '../../actions/menu-button/menu-button.js';
+import '../../inputs/text-input/text-input.js';
+import '../../../primitives/badge/badge.js';
+import '../../../primitives/button/button.js';
+import '../../../primitives/progress-bar/progress-bar.js';
+import type { MenuEntry } from '../../actions/menu-button/menu-button.js';
+import type { BadgeTone } from '../../../primitives/badge/badge.js';
+export interface ListItem {
+    id: string;
+    title: string;
+    /** Makes the title a link. */
+    href?: string;
+    /** The muted line under the title: "47:12 · 3 sprekers". */
+    sub?: string;
+    /** The fact on the right: "vandaag". */
+    meta?: string;
+    /** The row's menu: the rows of a `lintje-menu-button`. */
+    actions?: MenuEntry[];
+    /**
+     * The title as a field in place: `save` names the button ("Overal wijzigen (3)"), `error` stands
+     * under the field.
+     */
+    rename?: {
+        save: string;
+        error?: string;
+    };
+    /** One action in plain sight ("Annuleren"), sent as `lintje-row-action`; `href` makes it a link. */
+    action?: {
+        label: string;
+        value: string;
+        href?: string;
+    };
+    /** The kind of work, as an icon file name, before the title. */
+    icon?: string;
+    /** A data colour as a bar along the row (`sky-blue`): a speaker, as in the player and transcript. */
+    swatch?: string;
+    /** The state as a word ("Bezig"), drawn as a badge in the badge's tone. */
+    status?: {
+        label: string;
+        tone?: BadgeTone;
+    };
+    /** 0–100 while the work runs: a bar under the muted line, held (muted) when the status warns. */
+    progress?: number | null;
+    /** The heading that consecutive rows with the same value stand under ("Vandaag"). */
+    group?: string;
+    /** `false`: the row opens nothing — no row click, no hover; work that is still running. */
+    clickable?: boolean;
+}
+/** Consecutive items with the same `group` as one run; items without one form a run without a heading. */
+export declare function groupRuns(items: ListItem[]): {
+    label: string;
+    items: ListItem[];
+}[];
+export interface RowClickDetail {
+    id: string;
+    label: string;
+    href?: string;
+}
+export declare class LintjeList extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    items: ListItem[];
+    /** The row whose detail stands open beside the list. */
+    selectedId?: string;
+    emptyText: string;
+    label?: string;
+    /** The level of a run's heading ("Vandaag"): one below the heading the list stands under. */
+    headingLevel: 2 | 3 | 4 | 5 | 6;
+    private held;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private rowElements;
+    /** A row's controls: its title when it is one, and its action and menu. */
+    private controls;
+    private heldFocus;
+    /** Where the focus goes when its control left: the same row, the next, the previous, the list. */
+    private landing;
+    private refocus;
+    private renaming;
+    protected updated(changed: PropertyValues<this>): void;
+    private saveRename;
+    private renderRename;
+    private detail;
+    private onRowClick;
+    private onAction;
+    private renderTitle;
+    private renderAction;
+    private row;
+    private renderRun;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-list': LintjeList;
+    }
+}

package/dist-elements/types/components/tables/pagination/pagination.d.ts

@@ -0,0 +1,82 @@
+/**
+ * `<lintje-pagination>` — the "21–40 van 131 documenten" count on the left, "Vorige", page
+ * numbers and "Volgende" in the middle and, with `page-sizes`, the choice how many stand on a page
+ * on the right. Where the three do not fit on one line the count and the choice go below.
+ *
+ * It does not write the URL. With `href-template` every page is a link and a plain click is
+ * handed to the host as `lintje-navigate`; without one they are buttons. A choice shows at once
+ * and the host confirms it through `page` and `page-size`. Pages count from 1.
+ *
+ * Events: `lintje-page-change` `{ page }`; `lintje-page-size-change` `{ pageSize, page }`, where
+ * `page` is the one that keeps the first row in view; with `href-template` also
+ * `lintje-navigate` `{ href }`.
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../actions/menu-button/menu-button.js';
+export type PageSlot = number | 'gap';
+/**
+ * The page numbers to show for `page` of `pageCount` (both from 1): all up to seven, beyond that
+ * exactly seven slots so the row keeps its length. A `'gap'` hides at least two pages.
+ */
+export declare function pageRange(page: number, pageCount: number): PageSlot[];
+/** What the counted things are called, e.g. `{ many: 'documenten', one: 'document' }`. */
+export interface CountUnit {
+    many: string;
+    one: string;
+}
+/**
+ * "21–40 van 131 documenten": the rows on `page`, or `null` when the host gave no total. When
+ * everything fits on one page the range would repeat the total, so only the total stands.
+ */
+export declare function rangeText(page: number, pageSize?: number, total?: number, unit?: CountUnit): string | null;
+/** `"10, 20, 50"` → `[10, 20, 50]`: whole, positive, each once, in the host's order. */
+export declare function parsePageSizes(value: string | null): number[] | undefined;
+export declare class LintjePagination extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    page: number;
+    /** Without it the pages follow from `total` and `page-size`. */
+    pageCount?: number;
+    /** Rows over all pages, for the count. */
+    total?: number;
+    pageSize?: number;
+    /** `"10, 20, 50"`: draws the choice how many stand on a page. */
+    pageSizes?: number[];
+    /** What is counted, plural and singular: `unit="documenten" unit-one="document"`. */
+    unit?: string;
+    unitOne?: string;
+    /** `?pagina={page}`: every page becomes a link with that href. */
+    hrefTemplate?: string;
+    label: string;
+    /** Only the chevrons: "Vorige" and "Volgende" do not fit beside the numbers. */
+    protected compact: boolean;
+    /** The count and the size choice below the pages: the three zones do not fit on one line. */
+    protected stacked: boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    /**
+     * Drops the words when the row with them would not fit on one line. It always measures the row
+     * with the words, shown for the measurement only, so the choice never flips back and forth.
+     */
+    private fit;
+    private get count();
+    private get current();
+    private hrefFor;
+    private choose;
+    private get countUnit();
+    private chooseSize;
+    private sizes;
+    /** Focus stays on the used control, else the current page, else the other step (phone). */
+    private keepFocus;
+    private step;
+    private number;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-pagination': LintjePagination;
+    }
+}

package/dist-elements/types/components/tables/sortable-list/sortable-list.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `<lintje-sortable-list>` — rows reordered by dragging a grip or with the keyboard.
+ *
+ * Only the grip starts a drag, so on a phone the list still scrolls under a finger on the row. A
+ * tap on a grip picks its row up as the keyboard does, and a tap on a grip puts it down there.
+ * It reorders its own copy of `items` until the host sends new ones and tells an order once, when
+ * a row is put down at a new place. Every step is read out by a `role="status"`.
+ *
+ * Events: `lintje-change` (ids, not composed); `lintje-values-change` `{ [name]: ids }` with a
+ * `name`; `lintje-checked-change` (ids) with `checkable`.
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../inputs/checkbox/checkbox.js';
+export interface SortableItem {
+    id: string;
+    label: string;
+    /** With `checkable`: whether the box is ticked. */
+    checked?: boolean;
+}
+export declare function moveItem<T>(list: readonly T[], from: number, to: number): T[];
+/** Where a dragged row lands: how many of the other rows (`middles`, top to bottom) are above. */
+export declare function dropIndex(middles: readonly number[], pointerY: number): number;
+interface Drag {
+    id: string;
+    from: number;
+    to: number;
+    startY: number;
+    dy: number;
+    middles: number[];
+    pointerId: number;
+}
+export declare class LintjeSortableList extends LintjeElement {
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    items: SortableItem[];
+    /** The filter key. Without it an order is only told to the component that drew the list. */
+    name: string;
+    label?: string;
+    /** A checkbox in every row, labelled with the row's name. */
+    checkable: boolean;
+    protected order: SortableItem[];
+    protected grabbed: {
+        id: string;
+        from: number;
+    } | null;
+    protected drag: Drag | null;
+    protected message: string;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private indexOf;
+    private place;
+    private commit;
+    private focusGrip;
+    private pickUp;
+    private putDown;
+    private putBack;
+    /** Puts the row in the hand down at the place of `target`'s row. */
+    private dropAt;
+    private onGripKeydown;
+    private onGripBlur;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onPointerCancel;
+    private onCheck;
+    private dropLine;
+    private row;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-sortable-list': LintjeSortableList;
+    }
+}
+export {};

package/dist-elements/types/components/tables/tree-view/tree-view.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `<lintje-tree-view>` — a hierarchy that folds open and shut, one tab stop with roving focus.
+ *
+ * `expanded` is the host's: the element folds its own copy and reports each fold, so a host that
+ * loads children on demand answers with `loading` and then `children`. It fetches nothing.
+ *
+ * Events: `lintje-node-toggle` `{ id, open }`; `lintje-change` (id, not composed);
+ * `lintje-values-change` `{ [name]: id }` with a `name`.
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../../primitives/spinner/spinner.js';
+export interface TreeNode {
+    id: string;
+    label: string;
+    /** The children, when the host has them. Present (even empty) makes the node a branch. */
+    children?: TreeNode[];
+    /** How many children there are, for a shut branch; without `children` a count makes it one. */
+    count?: number;
+    loading?: boolean;
+}
+export interface VisibleRow {
+    node: TreeNode;
+    level: number;
+    parentId: string | null;
+}
+export declare function isBranch(node: TreeNode): boolean;
+export declare function visibleRows(nodes: readonly TreeNode[], open: ReadonlySet<string>, level?: number, parentId?: string | null): VisibleRow[];
+/** The next row after `from` whose label starts with `letter`, wrapping round; or -1. */
+export declare function typeAhead(rows: readonly VisibleRow[], from: number, letter: string): number;
+export declare class LintjeTreeView extends LintjeElement {
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    nodes: TreeNode[];
+    /** The host's open branches. The element folds its own copy. */
+    expanded: string[];
+    selectedId?: string;
+    /** The filter key. Without it a choice is only told to the component that drew the tree. */
+    name: string;
+    /** The tree's accessible name; without it "Boomstructuur", which says little: give one. */
+    label?: string;
+    protected open: Set<string>;
+    protected focusId: string | null;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private get rows();
+    private tabStop;
+    private toggle;
+    private choose;
+    private moveFocus;
+    private onKeydown;
+    private arrow;
+    private item;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-tree-view': LintjeTreeView;
+    }
+}

package/dist-elements/types/core/element.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `LintjeElement` — the base class every `lintje-…` tag extends: prepends the tokens and reset
+ * to its styles, resolves the mode onto the host, and emits composed events.
+ *
+ * The mode resolves in this order: the element's own attribute; the nearest ancestor's
+ * `data-mode` (across shadow roots); its `data`; the default.
+ */
+import { LitElement, type CSSResultGroup, type CSSResultOrNative, type PropertyDeclarations, type PropertyValues } from 'lit';
+export type Mode = 'light' | 'dark';
+export interface FrameSettings {
+    mode?: Mode;
+}
+export declare class LintjeElement extends LitElement {
+    static properties: PropertyDeclarations;
+    mode?: Mode;
+    resolvedMode: Mode;
+    protected static finalizeStyles(styles?: CSSResultGroup): Array<CSSResultOrNative>;
+    /** The settings the element's `data` carries; a view element overrides it. */
+    protected get dataSettings(): FrameSettings | undefined;
+    connectedCallback(): void;
+    /**
+     * Data from the markup, for a page a server renders: a `<script type="application/json">`
+     * child is parsed into the property its `data-prop` names (default `data`) and removed, so no
+     * slot sees it. Read when the element connects and before its first render; after that the
+     * property is the host's.
+     */
+    private readDataSources;
+    disconnectedCallback(): void;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    /** Resolves the mode and reflects it. Public for the document observer. */
+    resolveSettings(): void;
+    /** Bubbling and composed, so it reaches the host; `false` when a listener cancelled it. */
+    protected emit(name: string, detail?: unknown): boolean;
+    /**
+     * Reports a link the reader chose as `lintje-navigate`. A host that routes itself cancels the
+     * event; otherwise the browser follows the click or, without a click (a key), the element goes
+     * there: the one place an element navigates.
+     */
+    protected followLink(href: string, event?: Event, detail?: unknown): void;
+    /** Bubbling but not composed: stops at the shadow root and never reaches a host. */
+    protected emitLocal(name: string, detail?: unknown): void;
+}
+/** Asks every connected element to render again; called when a late icon arrives. */
+export declare function redrawAllElements(): void;
+export declare function define(tag: string, element: CustomElementConstructor): void;

package/dist-elements/types/core/focus.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Where the focus is, through every shadow root, and whether a modal dialog stands around a
+ * node. In `core/` because primitives and components both need it.
+ */
+/** The element that really has focus, through every shadow root below it. */
+export declare function deepActiveElement(): HTMLElement | null;
+/** The open modal dialog (`aria-modal="true"`) the node stands in, through every root. */
+export declare function modalAround(node: Node | null): Element | null;
+/** Whether an Escape is `element`'s to answer: not when a modal dialog opened over it has focus. */
+export declare function ownsEscape(element: Element): boolean;
+/** Whether `node` is `ancestor` or stands inside it, through every shadow root and slot. */
+export declare function standsIn(node: Node, ancestor: Node): boolean;
+/** Whether the focus is on `element` or anything inside it, through every shadow root and slot. */
+export declare function holdsFocus(element: Element): boolean;

package/dist-elements/types/core/format.d.ts

@@ -0,0 +1,13 @@
+/** Number formatting for the charts (Dutch locale). */
+export declare function formatNumber(n: number, decimals?: number): string;
+/** In full if it fits, otherwise abbreviated (121k). */
+export declare function formatCompactNumber(n: number): string;
+/** Full if it fits in `available` px, otherwise abbreviated. */
+export declare function formatDataLabel(n: number, available: number): string;
+/** Whether a data label fits in `available` px: ~6.5 px per character at 12 px. */
+export declare function dataLabelFits(text: string, available: number): boolean;
+/** `text` shortened with an ellipsis until it fits `maxWidth` px in the axis label font. */
+export declare function truncateToWidth(text: string, maxWidth: number, fontFamily?: string): string;
+/** Width in px of `text` in the 12 px axis label font; ~6.5 px per character without a canvas. */
+export declare function textWidth(text: string, fontFamily?: string): number;
+export declare function formatPercent(n: number, decimals?: number): string;

package/dist-elements/types/core/frame-state.d.ts

@@ -0,0 +1,30 @@
+/**
+ * State shared between elements: a module-level store, since every element runs from the same
+ * module. It holds only what one part of the shell tells another; `FrameStateController`
+ * subscribes an element to it.
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+export interface FrameState {
+    titleHidden: boolean;
+    scrolled: boolean;
+    sheetOpen: boolean;
+    /** Filters that differ from their default, for the mobile header's badge. */
+    modifiedCount: number;
+    summary: string;
+    hasFilters: boolean;
+}
+export declare function getFrameState(): FrameState;
+export declare function setFrameState(patch: Partial<FrameState>): void;
+export declare const setTitleHidden: (titleHidden: boolean) => void;
+export declare const setScrolled: (scrolled: boolean) => void;
+export declare function subscribeToFrameState(listener: () => void): () => void;
+export declare class FrameStateController implements ReactiveController {
+    private readonly host;
+    private unsubscribe;
+    constructor(host: ReactiveControllerHost);
+    get state(): FrameState;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+/** A page without a zone must not inherit the count, sentence or open sheet of the last one. */
+export declare function clearFilterZone(): void;

package/dist-elements/types/core/host-config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What a host page tells the elements about itself. One instance for the whole bundle.
+ */
+export interface HostConfig {
+    /** The element that scrolls the page: overlays lock it. Default: the document's scroller. */
+    scrollRoot: () => HTMLElement | null;
+}
+/** The host says what it knows, once, before the first element renders. */
+export declare function setHostConfig(patch: Partial<HostConfig>): void;
+/** The element that scrolls the page, as the host named it. */
+export declare function scrollRoot(): HTMLElement | null;
+/**
+ * Sets `overflow: hidden` on `element` and returns the undo. Locks are counted: the last undo
+ * restores the original overflow, so overlays may close in any order. An undo works once.
+ */
+export declare function holdOverflow(element: HTMLElement): () => void;
+/**
+ * Locks the page behind an overlay and returns the undo. On the document's own scroller that is
+ * `document.body`: `overflow: hidden` there leaves `<html>`'s scrollbar gutter alone, so the
+ * page does not jump sideways.
+ */
+export declare function lockScroll(): () => void;

package/dist-elements/types/core/length.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A length token in px, e.g. `lengthPx(this, '--h-topbar', 56)`. Read where the element stands,
+ * so a breakpoint's override applies; `rem` resolves against the root font size. Anything that is
+ * not px, rem or a bare number gives the fallback.
+ */
+export declare function lengthPx(element: Element, token: string, fallback: number): number;

package/dist-elements/types/core/links.d.ts

@@ -0,0 +1,2 @@
+/** True for a plain left click; a modifier or another button is left to the browser. */
+export declare function isPlainClick(event: MouseEvent): boolean;

package/dist-elements/types/core/media.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A media query as a Lit reactive controller (viewport decisions, rule 9). One `MediaQueryList`
+ * per query string is shared by every controller.
+ */
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/** Below this the views take their phone representation (rule 9). */
+export declare const MOBILE = "(max-width: 767px)";
+/** From here the menu can be pinned. The frame's markup changes at both breakpoints. */
+export declare const WIDE = "(min-width: 1440px)";
+export declare class MediaController implements ReactiveController {
+    #private;
+    /** Whether the query matches right now. */
+    matches: boolean;
+    constructor(host: ReactiveControllerHost, query?: string);
+    hostConnected(): void;
+    hostDisconnected(): void;
+}

package/dist-elements/types/core/motion.d.ts

@@ -0,0 +1,8 @@
+/** Motion an element runs itself rather than in CSS: durations read from tokens, reduced motion. */
+/**
+ * A duration token in milliseconds, read where the element stands so local overrides apply.
+ * The unit is parsed: a minifier writes `900ms` as `.9s`, which `parseFloat` alone reads as 0.9 ms.
+ */
+export declare function durationMs(element: Element, token: string): number;
+/** Whether the reader asked for less motion. */
+export declare function prefersReducedMotion(): boolean;

package/dist-elements/types/core/shortcuts.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The page's one register of keyboard shortcuts: one `keydown` listener; `shortcuts()` lists
+ * them for `<lintje-shortcuts>`. Without Ctrl, Alt or Meta a key never fires in a field; with
+ * one, only when registered with `inFields`. A key registered twice warns in development.
+ *
+ * A one-character key (`/`, `?`) can be switched off by the reader (WCAG 2.1.4, for speech
+ * input and stray keystrokes): `setCharacterKeys(false)`, remembered in `localStorage`.
+ */
+export interface ShortcutOptions {
+    /** One key with optional modifiers joined by `+`: `'/'`, `'Ctrl+S'`. A letter ignores case. */
+    keys: string;
+    /** What the key does, in Dutch: the line in the overview. */
+    description: string;
+    handler: (event: KeyboardEvent) => void;
+    /** Also while the focus is in a field; only with Ctrl, Alt or Meta. */
+    inFields?: boolean;
+}
+export interface ShortcutInfo {
+    keys: string;
+    description: string;
+    inFields: boolean;
+}
+interface Chord {
+    key: string;
+    ctrl: boolean;
+    alt: boolean;
+    meta: boolean;
+    shift: boolean;
+}
+/** Whether the one-character keys work: on, unless the reader switched them off. */
+export declare function characterKeys(): boolean;
+export declare function setCharacterKeys(on: boolean): void;
+/** A printable character without Ctrl, Alt or Meta: the kind of key the reader can switch off. */
+export declare function isCharacterKey(keys: string): boolean;
+/** `'Ctrl+S'` → `{ key: 's', ctrl: true, … }`. A `+` on its own is the key. */
+export declare function parseKeys(keys: string): Chord;
+/** Whether the event is this chord. */
+export declare function matchesKeys(chord: Chord, event: KeyboardEvent): boolean;
+export declare function isTypingTarget(event: Event): boolean;
+/** Adds a shortcut; the returned function removes it. */
+export declare function registerShortcut(options: ShortcutOptions): () => void;
+export declare function shortcuts(): ShortcutInfo[];
+export declare function keyLabels(keys: string): string[];
+/** The value for `aria-keyshortcuts` on the control the key belongs to: `'Control+S'`. */
+export declare function ariaKeyShortcuts(keys: string): string;
+export {};

package/dist-elements/types/core/style-props.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Inline styles that survive a strict Content-Security-Policy. `style-src 'self'` makes a browser
+ * discard the `style` attribute, which Lit writes; `styleProps` is an element directive that
+ * writes through the CSSOM instead. A `null`, `undefined` or `false` value removes the property.
+ */
+import { nothing } from 'lit';
+import { Directive, type ElementPart, type PartInfo } from 'lit/directive.js';
+export type StyleProps = Record<string, string | number | null | undefined | false>;
+declare class StylePropsDirective extends Directive {
+    /** What this part set last, so a property that disappears is removed and not left behind. */
+    private applied;
+    constructor(partInfo: PartInfo);
+    render(_props: StyleProps): typeof nothing;
+    update(part: ElementPart, [props]: [StyleProps]): typeof nothing;
+}
+/** Applies CSS declarations to the element through the CSSOM. */
+export declare const styleProps: (_props: StyleProps) => import("lit-html/directive.js").DirectiveResult<typeof StylePropsDirective>;
+export {};

package/dist-elements/types/core/styles.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Plain BEM CSS (`?inline`) as a shadow-root stylesheet: `shadowCss()` rewrites document-level
+ * selectors onto `:host` and caches one `CSSResult` per source, so a sheet is parsed once.
+ */
+import { type CSSResult } from 'lit';
+/**
+ * Document-level selectors onto the element itself.
+ *
+ * - `@font-face` is dropped: Chromium ignores it in a shadow root; the host page declares fonts.
+ * - `:root:not(X)` becomes `:host(:not(X))`: `:host:not(X)` does not match in Chromium.
+ *   It runs before the plain `:root` rule.
+ */
+export declare function toShadowCss(css: string): string;
+/** The stylesheet of one copied CSS file, scoped to the shadow root and shared. */
+export declare function shadowCss(css: string): CSSResult;
+export declare const tokenStyles: CSSResult;
+export declare const baseStyles: CSSResult;

package/dist-elements/types/core/version.d.ts

@@ -0,0 +1 @@
+export declare const LINTJE_VERSION: string;

package/dist-elements/types/icons/icon/icon.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `<lintje-icon>` — one icon, named by its file in `dist-icons/` (without `.svg`).
+ *
+ * For plain HTML pages; inside a component use `renderIcon()` (`../render.ts`), which this
+ * element also draws through. Resolution: `src`, the register, loaded icons, then nothing.
+ * Events: none.
+ */
+import { nothing, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../core/element.js';
+import { ICONS, type IconGlyph, type IconName } from '../register.js';
+export type { IconName, IconGlyph };
+export { ICONS };
+/** The names the bundle carries; every other name is fetched. */
+export declare const ICON_NAMES: readonly string[];
+export declare class LintjeIcon extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    static properties: {
+        name: {
+            type: StringConstructor;
+        };
+        src: {
+            type: StringConstructor;
+        };
+        size: {
+            type: NumberConstructor;
+        };
+        label: {
+            type: StringConstructor;
+        };
+        lazy: {
+            type: BooleanConstructor;
+        };
+    };
+    name?: string;
+    /** An SVG file the host resolved, as a URL or data URI. Wins over `name`. */
+    src?: string;
+    /** 14 status, 16 text line, 18 button, 20 menu. */
+    size: number;
+    /** Makes the icon an image with this name; without it the icon is decorative. */
+    label?: string;
+    /** Asks for the file only once the icon is near the viewport. */
+    lazy: boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected render(): TemplateResult | typeof nothing;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-icon': LintjeIcon;
+    }
+}