@expressivecss/expressive 0.14.1 → 0.16.0

package/dist/types/components/cards.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement, Openable } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export interface CardsOptions extends BaseOptions {
     onOpen: (el: Element) => void;
     onClose: (el: Element) => void;
@@ -11,7 +11,7 @@ export interface CardsOptions extends BaseOptions {
  */
 export declare const CARDS_SELECTOR = "article:has(> aside[id]:not([id=\"\"])):not(:has(> aside ~ aside)):has(> button.card-reveal-trigger[type=\"button\"], > :not(aside) button.card-reveal-trigger[type=\"button\"])";
 export declare function isCardReveal(el: Element): el is HTMLElement;
-export declare class Cards extends Component<CardsOptions> implements Openable {
+export declare class Cards extends Component<CardsOptions> {
     isOpen: boolean;
     private readonly cardReveal;
     private _activators;
@@ -20,25 +20,12 @@ export declare class Cards extends Component<CardsOptions> implements Openable {
     private _lastActivator;
     constructor(el: HTMLElement, options?: Partial<CardsOptions>);
     static get defaults(): CardsOptions;
-    /**
-     * Initializes instance of Cards.
-     * @param el HTML element.
-     * @param options Component options.
-     */
-    static init(el: HTMLElement, options?: Partial<CardsOptions>): Cards;
-    /**
-     * Initializes instances of Cards.
-     * @param els HTML elements.
-     * @param options Component options.
-     */
-    static init(els: InitElements<InitElement>, options?: Partial<CardsOptions>): Cards[];
-    static getInstance(el: HTMLElement): Cards;
+    static key: string;
     /**
      * {@inheritDoc}
      */
     destroy(): void;
     _setupEventHandlers: () => void;
-    _removeEventHandlers: () => void;
     _handleClickInteraction: (event: MouseEvent) => void;
     _handleKeydownEvent: (event: KeyboardEvent) => void;
     _handleRevealEvent: () => void;

package/dist/types/components/carousel.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export interface CarouselI18nOptions {
     carousel: string;
     item: string;
@@ -15,12 +15,6 @@ export interface CarouselOptions extends BaseOptions {
      * @default 200
      */
     duration: number;
-    /**
-     * Full-width compatibility track. Material 3 layouts are already linear.
-     * Also implied by `.flat`.
-     * @default false
-     */
-    fullWidth: boolean;
     /**
      * Show paging dots. Only drawn when there is more than one item.
      * @default false
@@ -82,7 +76,6 @@ export declare class Carousel extends Component<CarouselOptions> {
     private _vertical;
     private _resizeObserver;
     private _resizeTimeout;
-    private _usesWindowResize;
     private _dragPointerId;
     private _dragStartX;
     private _dragStartY;
@@ -108,20 +101,14 @@ export declare class Carousel extends Component<CarouselOptions> {
     private _authoredItemSizes;
     private _itemA11yOriginal;
     private get _scroller();
-    private static _live;
-    private static _resizeListening;
-    private static _onResize;
     constructor(el: HTMLElement, options: Partial<CarouselOptions>);
     static get defaults(): CarouselOptions;
-    static init(el: HTMLElement, options?: Partial<CarouselOptions>): Carousel;
-    static init(els: InitElements<InitElement>, options?: Partial<CarouselOptions>): Carousel[];
-    static getInstance(el: HTMLElement): Carousel;
+    static key: string;
     destroy(): void;
     private _collectItems;
     private _setupAccessibility;
     private _setupIndicators;
     _setupEventHandlers(): void;
-    _removeEventHandlers(): void;
     private _teardown;
     _handleThrottledResize: () => void;
     _handleAutoAdvanceState: (e: Event) => void;
@@ -140,10 +127,17 @@ export declare class Carousel extends Component<CarouselOptions> {
     _handleTrackDragStart: (e: DragEvent) => void;
     private _handleItemResize;
     _handleIndicatorClick: (e: Event) => void;
+    /**
+     * Keys the carousel leaves alone. Modified keys are shortcuts (Alt+Left is
+     * Back), and a nested widget that reads arrows itself - a field, a slider,
+     * tabs, a menu, media controls - keeps them.
+     */
+    private _keyBelongsElsewhere;
     _handleKeydown: (e: KeyboardEvent) => void;
     _handleTrackScroll: () => void;
     _handleResize: () => void;
     private _paintIndicators;
+    /** Whether `index` is still the active item once its change is reported. */
     private _syncActive;
     private _syncLayoutRoles;
     private _syncAdaptiveMode;

package/dist/types/components/cascader.d.ts

@@ -0,0 +1,130 @@
+import { Component, BaseOptions } from '../core/component';
+export interface CascaderI18nOptions {
+    /** What a required field says while no path is chosen. */
+    required: string;
+}
+export interface CascaderOptions extends BaseOptions {
+    /**
+     * Text the cascader shows.
+     * @default { required: 'Choose an option.' }
+     */
+    i18n: CascaderI18nOptions;
+}
+export declare class Cascader extends Component<CascaderOptions> {
+    /** The text input that shows the chosen path. */
+    input: HTMLInputElement;
+    /** The popover of columns. */
+    popover: HTMLElement;
+    /** The options from the author's lists. */
+    private _options;
+    /** The chosen path, from the first column to a leaf, or empty. */
+    private _path;
+    /** Whether the popover is open. */
+    isOpen: boolean;
+    /** The input's attributes before the component started. */
+    private _saved;
+    /** The path shown while the popover is open, which a leaf commits. */
+    private _open;
+    /** The open listbox columns, one per level of the open path. */
+    private _columns;
+    /** Each rendered option's node. */
+    private _nodes;
+    /** Each node's current option; choosing a branch again renders it anew. */
+    private _rendered;
+    /** The last press inside the field, which the document listener lets through. */
+    private _insidePress;
+    /** Listeners that last while the popover is open. */
+    private _openEvents;
+    /** What names the popover and the first column: the input's own aria-labelledby or its label's id. */
+    private _labelledBy;
+    /** A label id the component gave, which destroy() takes back. */
+    private _stampedLabel;
+    private _ids;
+    /** The path the field started with, which a form reset puts back. */
+    private _initialPath;
+    /** The form control wrapping a named input, which the form reads instead of it. */
+    private _control;
+    /** The form name the input had, which the control submits under. */
+    private _formName;
+    private _required;
+    constructor(el: HTMLElement, options?: Partial<CascaderOptions>);
+    static get defaults(): CascaderOptions;
+    static key: string;
+    /** The values of the chosen path, from the first column on. */
+    get value(): string[];
+    /** Opens the popover at the chosen path, with focus on its leaf or on the first option. */
+    open(): void;
+    /** Closes the popover, keeping the chosen path. */
+    close(): void;
+    destroy(): void;
+    /** The path to the first leaf marked data-selected; a marked branch does not count. */
+    private _startingPath;
+    /** Shows the popover anchored to the input, until a press outside closes it. */
+    private _showPopover;
+    /** The id of the input's first label, given one if it has none, or null. */
+    private _labelId;
+    /** Names the popover or the first column after the field. */
+    private _name;
+    /** A listbox of `nodes`, named after the option that opened it, or after the field for the first. */
+    private _addColumn;
+    private _addOption;
+    /** The rendered option for `node`, if it is shown. */
+    private _optionFor;
+    /**
+     * Puts `node` on the open path at `level`: it is selected in its column,
+     * the columns after it go, and a branch shows its children next.
+     */
+    private _choose;
+    /** Moves focus to an option and makes it its column's tab stop. */
+    private _focus;
+    /**
+     * A named input would submit the path's labels. The control submits under
+     * that name instead, one value per level, so the input gives its name and
+     * required up until destroy().
+     */
+    private _takeName;
+    /** Wraps the input in the control, which takes its required too. */
+    private _wrap;
+    /** After the path changes: one form value per level, and a required field's validity. */
+    private _sync;
+    /** A required field is missing a value until a path is committed; the message anchors at the input. */
+    private _validate;
+    /** A validity flag needs a message, so an empty i18n.required falls back to the default. */
+    private get _requiredMessage();
+    /** A form reset puts the starting path back without firing events. */
+    private _reset;
+    /** Unwraps the input and gives it its name and required back. */
+    private _giveNameBack;
+    /** Commits the open path, ending at a leaf: the input shows it, and changes to it fire input and change. */
+    private _commit;
+    /** Chooses an option: a branch opens its children, and a leaf commits the path. */
+    private _pick;
+    /** Moves into the next column from a branch; a leaf has none. */
+    private _forward;
+    /** Enter and Space: a branch opens the next column, and a leaf commits. */
+    private _activate;
+    /** Chooses a branch and moves focus to the first option of its column. */
+    private _enter;
+    /** Back to the option that opened this column, leaving the columns as they are. */
+    private _back;
+    /** Closes without committing and returns focus to the input. */
+    private _dismiss;
+    /** Up, Down, Home and End within a column, without wrapping. */
+    private _move;
+    /** What each key does on an option, by its left-to-right name. */
+    private _keys;
+    /** The key's left-to-right name, so ArrowLeft and ArrowRight follow the columns under dir="rtl". */
+    private _keyName;
+    _handleInputKeydown: (e: KeyboardEvent) => void;
+    _handleOptionKeydown: (e: KeyboardEvent) => void;
+    /** A submit or checkValidity() found no path: the input says so to assistive technology. */
+    _handleInvalid: () => void;
+    _handleInputClick: () => void;
+    /** A click on a branch keeps focus on it; one on a leaf commits. */
+    _handleOptionClick: (e: MouseEvent) => void;
+    _handleInsidePointer: (e: PointerEvent) => void;
+    /** A press outside the field and the popover closes it, leaving focus where the press puts it. */
+    _handleOutsidePointer: (e: PointerEvent) => void;
+    /** Shows the chosen path's labels in the input. */
+    private _show;
+}

package/dist/types/components/characterCounter.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 type InputElement = HTMLInputElement | HTMLTextAreaElement;
 export declare class CharacterCounter extends Component<BaseOptions> {
     el: InputElement;
@@ -10,22 +10,9 @@ export declare class CharacterCounter extends Component<BaseOptions> {
     isValidLength: boolean;
     constructor(el: HTMLInputElement | HTMLTextAreaElement, options: Partial<BaseOptions>);
     static get defaults(): BaseOptions;
-    /**
-     * Initializes instance of CharacterCounter.
-     * @param el HTML element.
-     * @param options Component options.
-     */
-    static init(el: InputElement, options?: Partial<BaseOptions>): CharacterCounter;
-    /**
-     * Initializes instances of CharacterCounter.
-     * @param els HTML elements.
-     * @param options Component options.
-     */
-    static init(els: InitElements<InputElement | InitElement>, options?: Partial<BaseOptions>): CharacterCounter[];
-    static getInstance(el: InputElement): CharacterCounter;
+    static key: string;
     destroy(): void;
     _setupEventHandlers(): void;
-    _removeEventHandlers(): void;
     _setupCounter(): void;
     _removeCounter(): void;
     updateCounter: () => void;

package/dist/types/components/chips.d.ts

@@ -1,5 +1,5 @@
 import { Autocomplete, AutocompleteOptions } from './autocomplete';
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export interface ChipData {
     /**
      * Unique identifier.
@@ -17,6 +17,8 @@ export interface ChipData {
 export interface ChipsI18nOptions {
     /** Prefix for the delete button's accessible name. */
     remove: string;
+    /** What a required field says while it has no chips. */
+    required: string;
 }
 export interface ChipsOptions extends BaseOptions {
     /**
@@ -61,8 +63,9 @@ export interface ChipsOptions extends BaseOptions {
     allowUserInput: boolean;
     /**
      * Strings the component generates. `remove` prefixes the delete button's
-     * accessible name, giving "Remove Apple".
-     * @default { remove: 'Remove' }
+     * accessible name, giving "Remove Apple". `required` is what a required
+     * field says while it has no chips.
+     * @default { remove: 'Remove', required: 'Add at least one item.' }
      */
     i18n: Partial<ChipsI18nOptions>;
     /**
@@ -91,8 +94,18 @@ export declare class Chips extends Component<ChipsOptions> {
     _input: HTMLInputElement;
     _label: HTMLLabelElement;
     _chips: HTMLElement[];
-    static _keydown: boolean;
     private _selectedChip;
+    /** The form name the text input had, which the chips submit instead. */
+    private _name;
+    /** The chips the field started with, which a form reset puts back. */
+    private _initialData;
+    /** The input's own aria-required, or null, put back on destroy. */
+    private _ariaRequired;
+    /** The form control wrapping a named input, which the form reads instead of it. */
+    private _control;
+    /** The named text input, whose form, disabled state and required the chips take over. */
+    private _source;
+    private _required;
     /**
      * Selection is drawn by a class now, not by `:focus`, so it does not clear
      * itself when focus moves - every path that changes the selection has to go
@@ -105,33 +118,66 @@ export declare class Chips extends Component<ChipsOptions> {
     private _setSelected;
     constructor(el: HTMLElement, options: Partial<ChipsOptions>);
     static get defaults(): ChipsOptions;
+    static key: string;
+    getData(): ChipData[];
+    destroy(): void;
+    _setupEventHandlers(): void;
     /**
-     * Initializes instance of Chips.
-     * @param el HTML element.
-     * @param options Component options.
+     * A text input with a `name` would submit whatever is half typed. The chips
+     * submit under that name instead, one value per chip, as a multiple select
+     * does, so the input gives its name up until destroy().
      */
-    static init(el: HTMLElement, options?: Partial<ChipsOptions>): Chips;
+    private _takeName;
     /**
-     * Initializes instances of Chips.
-     * @param els HTML elements.
-     * @param options Component options.
+     * Wraps the input in the form control, which takes its name and required.
+     * `display: contents` lays the input out as a child of the field still.
      */
-    static init(els: InitElements<InitElement>, options?: Partial<ChipsOptions>): Chips[];
-    static getInstance(el: HTMLElement): Chips;
-    getData(): ChipData[];
-    destroy(): void;
-    _setupEventHandlers(): void;
-    _removeEventHandlers(): void;
+    private _wrap;
+    /**
+     * The editor's text field, or null. A static .chips of filter checkboxes,
+     * which AutoInit also starts, keeps its own native form values.
+     */
+    private _editorInput;
+    /** Where the text field ends: chips go before it, and it goes last. */
+    private get _end();
+    /** After the chips change: give the form one value per chip and update a required field's validity. */
+    private _sync;
+    /**
+     * The chips are what is required, not the text, so `required` moves to the
+     * control, and aria-required keeps telling assistive technology.
+     */
+    private _takeRequired;
+    /**
+     * A required field is valid once it has a chip, whatever is half typed. The
+     * control holds this validity, apart from any error the page sets on the
+     * input, and anchors it at the input, which a submit then focuses.
+     */
+    private _validate;
+    /** The input, unless page script moved it out of the control, where it cannot anchor the message. */
+    private get _anchor();
+    /** A validity flag needs a message, so an empty i18n.required falls back to the default. */
+    private get _requiredMessage();
+    private _resetChips;
+    /** Unwraps the input, with whatever else went in the control, and gives it its name and required back. */
+    private _giveNameBack;
+    /** Whether only an autocomplete suggestion can become a chip. */
+    private get _suggestionsOnly();
+    /** Pasted text that lists several values, split by commas, tabs or lines, adds a chip for each. */
+    _handleInputPaste: (e: ClipboardEvent) => void;
     _handleChipClick: (e: MouseEvent) => void;
+    /** The arrow that points back towards the first chip, which in RTL is Right. */
+    private static _backKey;
     static _handleChipsKeydown(e: KeyboardEvent): void;
-    static _handleChipsKeyup(): void;
-    static _handleChipsBlur(e: Event): void;
+    _handleFocusIn: (e: FocusEvent) => void;
+    _handleFocusOut: (e: FocusEvent) => void;
     _handleInputFocus: () => void;
     _handleInputBlur: () => void;
     _handleInputKeydown: (e: KeyboardEvent) => void;
     _renderChip(chip: ChipData): HTMLElement;
     _renderChips(): void;
     _setupAutocomplete(): void;
+    /** The "Add" row is a deliberate choice, so it adds a chip even in an autocompleteOnly field. */
+    private _addTyped;
     _setupInput(): void;
     _setupLabel(): void;
     _setPlaceholder(): void;

package/dist/types/components/colorPicker.d.ts

@@ -0,0 +1,42 @@
+import { Component, BaseOptions } from '../core/component';
+export interface ColorPickerOptions extends BaseOptions {
+    /**
+     * Called with the new `#rrggbb` value when a change is committed: the end
+     * of a drag, a key press, a hue release or a typed hex value.
+     * @default null
+     */
+    onChange: ((value: string) => void) | null;
+}
+/**
+ * Color picker. Enhances a `.color-picker` holding an `<input type="color">`
+ * with a saturation and brightness area, a hue slider and a hex field. The
+ * native input stays the form value and the preview, so the browser's own
+ * picker still opens from it, and it fires `input` and `change` as it would
+ * if the person had used that picker.
+ */
+export declare class ColorPicker extends Component<ColorPickerOptions> {
+    /** The native color input that holds the value. */
+    input: HTMLInputElement | null;
+    private _hsv;
+    private _area;
+    private _thumb;
+    private _hue;
+    private _hex;
+    private _writing;
+    constructor(el: HTMLElement, options: Partial<ColorPickerOptions>);
+    static get defaults(): ColorPickerOptions;
+    static key: string;
+    destroy(): void;
+    /** The current color as `#rrggbb`. Setting it fires no events, as with a native input. */
+    get value(): string;
+    set value(hex: string);
+    private _build;
+    private _render;
+    private _set;
+    private _commit;
+    private _onNativeInput;
+    private _onHex;
+    private _fromPoint;
+    private _onPointerDown;
+    private _onKeyDown;
+}

package/dist/types/components/columnChart.d.ts

@@ -1,21 +1,34 @@
-import { InitElements, InitElement } from '../core/component';
-import { LineChart, LineChartOptions } from './lineChart';
+import { LineChart, LineChartOptions, Series } from './lineChart';
 export type ColumnChartOptions = LineChartOptions;
 /**
  * Column chart. It reads its <table>, scales, labels and tooltip like
  * LineChart, but draws each row as a group of columns from zero, or one
- * column of segments with `stacked`. Columns are HTML clipped to their
- * value, so their rounded corners keep their shape at any size.
+ * column of segments with `stacked`. A series whose header has `range`
+ * reads each cell as two ends and floats a column between them. Columns
+ * are HTML clipped to their value, so their rounded corners keep their
+ * shape at any size.
  *
- * Re-run `ColumnChart.init(el)` after changing the table.
+ * Call `update()` after changing the table, or start it with `watch` or
+ * `data-watch`.
  */
 export declare class ColumnChart extends LineChart {
+    /** The `range` series, whose columns float. */
+    private _ranges;
     protected get _type(): string;
-    protected get _key(): string;
     protected get _fromZero(): boolean;
     protected get _points(): boolean;
-    static init(el: HTMLElement, options?: Partial<ColumnChartOptions>): ColumnChart;
-    static init(els: InitElements<InitElement>, options?: Partial<ColumnChartOptions>): ColumnChart[];
-    static getInstance(el: HTMLElement): ColumnChart;
-    protected _draw(drawn?: import("./lineChart").Series[]): Element;
+    static key: string;
+    /** A `range` series' low ends become its base; ranges do not stack. */
+    protected _arrange(series: Series[]): void;
+    protected _draw(drawn?: Series[]): Element;
+    /**
+     * After update(), writes where a column grows from: its old ends, or for
+     * a column new to the chart, the zero line or the segment below it in a
+     * stack. Returns the next segment's start in a stack.
+     * ponytail: in a stacked mixed chart a new end-scale column starts from
+     * the start-scale stack; track `below` per scale if that matters.
+     */
+    private _start;
+    /** A series' column at a row before update(), as its top and bottom insets, or null without one. */
+    private _oldInsets;
 }

package/dist/types/components/commandPalette.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement, Openable } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export interface CommandPaletteOptions extends BaseOptions {
     /**
      * Letter that toggles the palette together with Command on Apple platforms
@@ -25,7 +25,7 @@ export interface CommandPaletteOptions extends BaseOptions {
  * button inside an option; running it clicks that element, so a page wires
  * commands with ordinary hrefs and click handlers.
  */
-export declare class CommandPalette extends Component<CommandPaletteOptions> implements Openable {
+export declare class CommandPalette extends Component<CommandPaletteOptions> {
     el: HTMLDialogElement;
     /** The search input. */
     input: HTMLInputElement;
@@ -35,21 +35,9 @@ export declare class CommandPalette extends Component<CommandPaletteOptions> imp
     private _generatedIds;
     /** Wires and refilters commands the page adds or removes later. */
     private _observer;
-    constructor(el: HTMLDialogElement, options: Partial<CommandPaletteOptions>);
+    constructor(el: HTMLElement, options: Partial<CommandPaletteOptions>);
     static get defaults(): CommandPaletteOptions;
-    /**
-     * Initializes instance of CommandPalette.
-     * @param el HTML element.
-     * @param options Component options.
-     */
-    static init(el: HTMLElement, options?: Partial<CommandPaletteOptions>): CommandPalette;
-    /**
-     * Initializes instances of CommandPalette.
-     * @param els HTML elements.
-     * @param options Component options.
-     */
-    static init(els: InitElements<InitElement>, options?: Partial<CommandPaletteOptions>): CommandPalette[];
-    static getInstance(el: HTMLElement): CommandPalette;
+    static key: string;
     /** If the palette is open. */
     get isOpen(): boolean;
     /** Opens the palette as a modal dialog with the search input focused. */
@@ -84,6 +72,13 @@ export declare class CommandPalette extends Component<CommandPaletteOptions> imp
     private _run;
     _handleInput: () => void;
     _handleKeydown: (e: KeyboardEvent) => void;
+    /**
+     * The first Escape clears a typed query and the next closes the palette.
+     * Chromium and Firefox clear a search input on their own; WebKit closed at
+     * once, and so did every engine for a text input. Escape that cancels an
+     * IME composition is left to the IME.
+     */
+    _handleEscape: (e: KeyboardEvent) => void;
     _handleListClick: (e: MouseEvent) => void;
     _handlePointerMove: (e: PointerEvent) => void;
     /**

package/dist/types/components/confetti.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export type ConfettiShape = 'square' | 'circle' | 'star';
 export interface ConfettiOptions extends BaseOptions {
     /**
@@ -87,9 +87,7 @@ export declare class Confetti extends Component<ConfettiOptions> {
     private _onClick;
     constructor(el: HTMLElement, options: Partial<ConfettiOptions>);
     static get defaults(): ConfettiOptions;
-    static init(el: HTMLElement, options?: Partial<ConfettiOptions>): Confetti;
-    static init(els: InitElements<InitElement>, options?: Partial<ConfettiOptions>): Confetti[];
-    static getInstance(el: HTMLElement): Confetti;
+    static key: string;
     /**
      * Bursts over the whole viewport. Resolves when the last piece is gone.
      */

package/dist/types/components/currencyInput.d.ts

@@ -0,0 +1,59 @@
+import { Component, BaseOptions } from '../core/component';
+export interface CurrencyInputOptions extends BaseOptions {
+    /** `invalid` is the validity message for text that holds no amount. */
+    i18n: Partial<{
+        invalid: string;
+    }>;
+}
+/**
+ * Currency input. Shows a text field's amount in the page's locale and the
+ * currency its `data-currency` attribute names once the field loses focus,
+ * shows the plain number while it has focus, and puts the plain number in the
+ * form data.
+ */
+export declare class CurrencyInput extends Component<CurrencyInputOptions> {
+    el: HTMLInputElement;
+    static key: string;
+    private _display;
+    /** Writes an amount for editing: the locale's digits and mark, no grouping or sign. */
+    private _edit;
+    /** Writes an amount as the form submits it: Latin digits, a `.` mark, no grouping. */
+    private _plain;
+    private _digits;
+    /** The locale's digits for 9876543210, and its decimal mark. */
+    private _native;
+    private _decimal;
+    constructor(el: HTMLInputElement, options: Partial<CurrencyInputOptions>);
+    static get defaults(): CurrencyInputOptions;
+    /** The amount the field holds, rounded as it shows, or null when it is empty or holds no digit. */
+    get value(): number | null;
+    /** Reads text in the locale's digits, or full-width ones from an IME, as an amount. */
+    private _read;
+    private _round;
+    /**
+     * Formats the starting value without events. It reads as a plain number
+     * first, the form the field submits, so a saved `1.234` stays 1.234.
+     */
+    private _start;
+    private _format;
+    /**
+     * Enter fires change while the field keeps focus. Formatting then would
+     * put the next keystroke after the currency sign, so the field waits for
+     * blur.
+     */
+    private _onChange;
+    /** Shows `amount` in the locale and currency, leaving text that reads as no amount as it is. */
+    private _show;
+    /** Shows the amount as a plain number to edit, with the caret at the end. */
+    private _onFocus;
+    /** Marks text that holds no amount invalid, and clears the mark once it holds one or is empty. */
+    private _validate;
+    private _onReset;
+    private _afterReset;
+    /** Puts the plain number in the form data in place of the formatted text. */
+    private _onFormData;
+    /** Whether the field has an entry in `form`'s data. */
+    private _submitsTo;
+    /** Stops formatting and clears the validity message, leaving the text as it is. */
+    destroy(): void;
+}