govuk_publishing_components 58.1.1 → 59.0.0

data/node_modules/choices.js/public/types/src/scripts/choices.d.ts

@@ -0,0 +1,210 @@
+import { Container, Dropdown, Input, List, WrappedInput, WrappedSelect } from './components';
+import { InputChoice } from './interfaces/input-choice';
+import { InputGroup } from './interfaces/input-group';
+import { Options } from './interfaces/options';
+import { StateChangeSet } from './interfaces/state';
+import Store from './store/store';
+import { ChoiceFull } from './interfaces/choice-full';
+import { GroupFull } from './interfaces/group-full';
+import { EventChoiceValueType, PassedElementType } from './interfaces';
+import { EventChoice } from './interfaces/event-choice';
+import { NoticeType, Templates } from './interfaces/templates';
+import { Searcher } from './interfaces/search';
+/**
+ * Choices
+ * @author Josh Johnson<josh@joshuajohnson.co.uk>
+ */
+declare class Choices {
+    static version: string;
+    static get defaults(): {
+        options: Partial<Options>;
+        allOptions: Options;
+        templates: Templates;
+    };
+    initialised: boolean;
+    initialisedOK?: boolean;
+    config: Options;
+    passedElement: WrappedInput | WrappedSelect;
+    containerOuter: Container;
+    containerInner: Container;
+    choiceList: List;
+    itemList: List;
+    input: Input;
+    dropdown: Dropdown;
+    _elementType: PassedElementType;
+    _isTextElement: boolean;
+    _isSelectOneElement: boolean;
+    _isSelectMultipleElement: boolean;
+    _isSelectElement: boolean;
+    _hasNonChoicePlaceholder: boolean;
+    _canAddUserChoices: boolean;
+    _store: Store<Options>;
+    _templates: Templates;
+    _lastAddedChoiceId: number;
+    _lastAddedGroupId: number;
+    _currentValue: string;
+    _canSearch: boolean;
+    _isScrollingOnIe: boolean;
+    _highlightPosition: number;
+    _wasTap: boolean;
+    _isSearching: boolean;
+    _placeholderValue: string | null;
+    _baseId: string;
+    _direction: HTMLElement['dir'];
+    _idNames: {
+        itemChoice: string;
+    };
+    _presetChoices: (ChoiceFull | GroupFull)[];
+    _initialItems: string[];
+    _searcher: Searcher<ChoiceFull>;
+    _notice?: {
+        type: NoticeType;
+        text: string;
+    };
+    _docRoot: ShadowRoot | HTMLElement;
+    constructor(element?: string | Element | HTMLInputElement | HTMLSelectElement, userConfig?: Partial<Options>);
+    init(): void;
+    destroy(): void;
+    enable(): this;
+    disable(): this;
+    highlightItem(item: InputChoice, runEvent?: boolean): this;
+    unhighlightItem(item: InputChoice, runEvent?: boolean): this;
+    highlightAll(): this;
+    unhighlightAll(): this;
+    removeActiveItemsByValue(value: string): this;
+    removeActiveItems(excludedId?: number): this;
+    removeHighlightedItems(runEvent?: boolean): this;
+    showDropdown(preventInputFocus?: boolean): this;
+    hideDropdown(preventInputBlur?: boolean): this;
+    getValue<B extends boolean = false>(valueOnly?: B): EventChoiceValueType<B> | EventChoiceValueType<B>[];
+    setValue(items: string[] | InputChoice[]): this;
+    setChoiceByValue(value: string | string[]): this;
+    /**
+     * Set choices of select input via an array of objects (or function that returns array of object or promise of it),
+     * a value field name and a label field name.
+     * This behaves the same as passing items via the choices option but can be called after initialising Choices.
+     * This can also be used to add groups of choices (see example 2); Optionally pass a true `replaceChoices` value to remove any existing choices.
+     * Optionally pass a `customProperties` object to add additional data to your choices (useful when searching/filtering etc).
+     *
+     * **Input types affected:** select-one, select-multiple
+     *
+     * @example
+     * ```js
+     * const example = new Choices(element);
+     *
+     * example.setChoices([
+     *   {value: 'One', label: 'Label One', disabled: true},
+     *   {value: 'Two', label: 'Label Two', selected: true},
+     *   {value: 'Three', label: 'Label Three'},
+     * ], 'value', 'label', false);
+     * ```
+     *
+     * @example
+     * ```js
+     * const example = new Choices(element);
+     *
+     * example.setChoices(async () => {
+     *   try {
+     *      const items = await fetch('/items');
+     *      return items.json()
+     *   } catch(err) {
+     *      console.error(err)
+     *   }
+     * });
+     * ```
+     *
+     * @example
+     * ```js
+     * const example = new Choices(element);
+     *
+     * example.setChoices([{
+     *   label: 'Group one',
+     *   id: 1,
+     *   disabled: false,
+     *   choices: [
+     *     {value: 'Child One', label: 'Child One', selected: true},
+     *     {value: 'Child Two', label: 'Child Two',  disabled: true},
+     *     {value: 'Child Three', label: 'Child Three'},
+     *   ]
+     * },
+     * {
+     *   label: 'Group two',
+     *   id: 2,
+     *   disabled: false,
+     *   choices: [
+     *     {value: 'Child Four', label: 'Child Four', disabled: true},
+     *     {value: 'Child Five', label: 'Child Five'},
+     *     {value: 'Child Six', label: 'Child Six', customProperties: {
+     *       description: 'Custom description about child six',
+     *       random: 'Another random custom property'
+     *     }},
+     *   ]
+     * }], 'value', 'label', false);
+     * ```
+     */
+    setChoices(choicesArrayOrFetcher?: (InputChoice | InputGroup)[] | ((instance: Choices) => (InputChoice | InputGroup)[] | Promise<(InputChoice | InputGroup)[]>), value?: string | null, label?: string, replaceChoices?: boolean, clearSearchFlag?: boolean, replaceItems?: boolean): this | Promise<this>;
+    refresh(withEvents?: boolean, selectFirstOption?: boolean, deselectAll?: boolean): this;
+    removeChoice(value: string): this;
+    clearChoices(clearOptions?: boolean, clearItems?: boolean): this;
+    clearStore(clearOptions?: boolean): this;
+    clearInput(): this;
+    _validateConfig(): void;
+    _render(changes?: StateChangeSet): void;
+    _renderChoices(): void;
+    _renderItems(): void;
+    _displayNotice(text: string, type: NoticeType, openDropdown?: boolean): void;
+    _clearNotice(): void;
+    _renderNotice(fragment?: DocumentFragment): void;
+    _getChoiceForOutput(choice: ChoiceFull, keyCode?: number): EventChoice;
+    _triggerChange(value: any): void;
+    _handleButtonAction(element: HTMLElement): void;
+    _handleItemAction(element: HTMLElement, hasShiftKey?: boolean): void;
+    _handleChoiceAction(element: HTMLElement): boolean;
+    _handleBackspace(items: ChoiceFull[]): void;
+    _loadChoices(): void;
+    _handleLoadingState(setLoading?: boolean): void;
+    _handleSearch(value?: string): void;
+    _canAddItems(): boolean;
+    _canCreateItem(value: string): boolean;
+    _searchChoices(value: string): number | null;
+    _stopSearch(): void;
+    _addEventListeners(): void;
+    _removeEventListeners(): void;
+    _onKeyDown(event: KeyboardEvent): void;
+    _onKeyUp(): void;
+    _onInput(): void;
+    _onSelectKey(event: KeyboardEvent, hasItems: boolean): void;
+    _onEnterKey(event: KeyboardEvent, hasActiveDropdown: boolean): void;
+    _onEscapeKey(event: KeyboardEvent, hasActiveDropdown: boolean): void;
+    _onDirectionKey(event: KeyboardEvent, hasActiveDropdown: boolean): void;
+    _onDeleteKey(event: KeyboardEvent, items: ChoiceFull[], hasFocusedInput: boolean): void;
+    _onTouchMove(): void;
+    _onTouchEnd(event: TouchEvent): void;
+    /**
+     * Handles mousedown event in capture mode for containetOuter.element
+     */
+    _onMouseDown(event: MouseEvent): void;
+    /**
+     * Handles mouseover event over this.dropdown
+     * @param {MouseEvent} event
+     */
+    _onMouseOver({ target }: Pick<MouseEvent, 'target'>): void;
+    _onClick({ target }: Pick<MouseEvent, 'target'>): void;
+    _onFocus({ target }: Pick<FocusEvent, 'target'>): void;
+    _onBlur({ target }: Pick<FocusEvent, 'target'>): void;
+    _onFormReset(): void;
+    _highlightChoice(el?: HTMLElement | null): void;
+    _addItem(item: ChoiceFull, withEvents?: boolean, userTriggered?: boolean): void;
+    _removeItem(item: ChoiceFull): void;
+    _addChoice(choice: ChoiceFull, withEvents?: boolean, userTriggered?: boolean): void;
+    _addGroup(group: GroupFull, withEvents?: boolean): void;
+    _createTemplates(): void;
+    _createElements(): void;
+    _createStructure(): void;
+    _initStore(): void;
+    _addPredefinedChoices(choices: (ChoiceFull | GroupFull)[], selectFirstOption?: boolean, withEvents?: boolean): void;
+    _findAndSelectChoiceByValue(value: string, userTriggered?: boolean): boolean;
+    _generatePlaceholderValue(): string | null;
+    _warnChoicesInitFailed(caller: string): void;
+}
+export default Choices;

data/node_modules/choices.js/public/types/src/scripts/components/container.d.ts

@@ -0,0 +1,36 @@
+import { ClassNames } from '../interfaces/class-names';
+import { PositionOptionsType } from '../interfaces/position-options-type';
+import { PassedElementType } from '../interfaces/passed-element-type';
+export default class Container {
+    element: HTMLElement;
+    type: PassedElementType;
+    classNames: ClassNames;
+    position: PositionOptionsType;
+    isOpen: boolean;
+    isFlipped: boolean;
+    isDisabled: boolean;
+    isLoading: boolean;
+    constructor({ element, type, classNames, position, }: {
+        element: HTMLElement;
+        type: PassedElementType;
+        classNames: ClassNames;
+        position: PositionOptionsType;
+    });
+    /**
+     * Determine whether container should be flipped based on passed
+     * dropdown position
+     */
+    shouldFlip(dropdownPos: number, dropdownHeight: number): boolean;
+    setActiveDescendant(activeDescendantID: string): void;
+    removeActiveDescendant(): void;
+    open(dropdownPos: number, dropdownHeight: number): void;
+    close(): void;
+    addFocusState(): void;
+    removeFocusState(): void;
+    enable(): void;
+    disable(): void;
+    wrap(element: HTMLElement): void;
+    unwrap(element: HTMLElement): void;
+    addLoadingState(): void;
+    removeLoadingState(): void;
+}

data/node_modules/choices.js/public/types/src/scripts/components/dropdown.d.ts

@@ -0,0 +1,21 @@
+import { ClassNames } from '../interfaces/class-names';
+import { PassedElementType } from '../interfaces/passed-element-type';
+export default class Dropdown {
+    element: HTMLElement;
+    type: PassedElementType;
+    classNames: ClassNames;
+    isActive: boolean;
+    constructor({ element, type, classNames, }: {
+        element: HTMLElement;
+        type: PassedElementType;
+        classNames: ClassNames;
+    });
+    /**
+     * Show dropdown to user by adding active state class
+     */
+    show(): this;
+    /**
+     * Hide dropdown from user
+     */
+    hide(): this;
+}

data/node_modules/choices.js/public/types/src/scripts/components/index.d.ts

@@ -0,0 +1,7 @@
+import Dropdown from './dropdown';
+import Container from './container';
+import Input from './input';
+import List from './list';
+import WrappedInput from './wrapped-input';
+import WrappedSelect from './wrapped-select';
+export { Dropdown, Container, Input, List, WrappedInput, WrappedSelect };

data/node_modules/choices.js/public/types/src/scripts/components/input.d.ts

@@ -0,0 +1,37 @@
+import { ClassNames } from '../interfaces/class-names';
+import { PassedElementType } from '../interfaces/passed-element-type';
+export default class Input {
+    element: HTMLInputElement;
+    type: PassedElementType;
+    classNames: ClassNames;
+    preventPaste: boolean;
+    isFocussed: boolean;
+    isDisabled: boolean;
+    constructor({ element, type, classNames, preventPaste, }: {
+        element: HTMLInputElement;
+        type: PassedElementType;
+        classNames: ClassNames;
+        preventPaste: boolean;
+    });
+    set placeholder(placeholder: string);
+    get value(): string;
+    set value(value: string);
+    addEventListeners(): void;
+    removeEventListeners(): void;
+    enable(): void;
+    disable(): void;
+    focus(): void;
+    blur(): void;
+    clear(setWidth?: boolean): this;
+    /**
+     * Set the correct input width based on placeholder
+     * value or input value
+     */
+    setWidth(): void;
+    setActiveDescendant(activeDescendantID: string): void;
+    removeActiveDescendant(): void;
+    _onInput(): void;
+    _onPaste(event: ClipboardEvent): void;
+    _onFocus(): void;
+    _onBlur(): void;
+}

data/node_modules/choices.js/public/types/src/scripts/components/list.d.ts

@@ -0,0 +1,14 @@
+export default class List {
+    element: HTMLElement;
+    scrollPos: number;
+    height: number;
+    constructor({ element }: {
+        element: HTMLElement;
+    });
+    prepend(node: Element | DocumentFragment): void;
+    scrollToTop(): void;
+    scrollToChildElement(element: HTMLElement, direction: 1 | -1): void;
+    _scrollDown(scrollPos: number, strength: number, destination: number): void;
+    _scrollUp(scrollPos: number, strength: number, destination: number): void;
+    _animateScroll(destination: number, direction: number): void;
+}

data/node_modules/choices.js/public/types/src/scripts/components/wrapped-element.d.ts

@@ -0,0 +1,21 @@
+import { ClassNames } from '../interfaces/class-names';
+import { EventTypes } from '../interfaces/event-type';
+import { EventMap } from '../interfaces';
+export default class WrappedElement<T extends HTMLInputElement | HTMLSelectElement> {
+    element: T;
+    classNames: ClassNames;
+    isDisabled: boolean;
+    constructor({ element, classNames }: {
+        element: any;
+        classNames: any;
+    });
+    get isActive(): boolean;
+    get dir(): string;
+    get value(): string;
+    set value(value: string);
+    conceal(): void;
+    reveal(): void;
+    enable(): void;
+    disable(): void;
+    triggerEvent<K extends EventTypes>(eventType: EventTypes, data?: EventMap[K]['detail']): void;
+}

data/node_modules/choices.js/public/types/src/scripts/components/wrapped-input.d.ts

@@ -0,0 +1,3 @@
+import WrappedElement from './wrapped-element';
+export default class WrappedInput extends WrappedElement<HTMLInputElement> {
+}

data/node_modules/choices.js/public/types/src/scripts/components/wrapped-select.d.ts

@@ -0,0 +1,20 @@
+import { ClassNames } from '../interfaces/class-names';
+import WrappedElement from './wrapped-element';
+import { GroupFull } from '../interfaces/group-full';
+import { ChoiceFull } from '../interfaces/choice-full';
+export default class WrappedSelect extends WrappedElement<HTMLSelectElement> {
+    classNames: ClassNames;
+    template: (data: object) => HTMLOptionElement;
+    extractPlaceholder: boolean;
+    constructor({ element, classNames, template, extractPlaceholder, }: {
+        element: HTMLSelectElement;
+        classNames: ClassNames;
+        template: (data: object) => HTMLOptionElement;
+        extractPlaceholder: boolean;
+    });
+    get placeholderOption(): HTMLOptionElement | null;
+    addOptions(choices: ChoiceFull[]): void;
+    optionsAsChoices(): (ChoiceFull | GroupFull)[];
+    _optionToChoice(option: HTMLOptionElement): ChoiceFull;
+    _optgroupToChoice(optgroup: HTMLOptGroupElement): GroupFull;
+}

data/node_modules/choices.js/public/types/src/scripts/constants.d.ts

@@ -0,0 +1 @@
+export declare const SCROLLING_SPEED: number;

data/node_modules/choices.js/public/types/src/scripts/defaults.d.ts

@@ -0,0 +1,4 @@
+import { ClassNames } from './interfaces/class-names';
+import { Options } from './interfaces/options';
+export declare const DEFAULT_CLASSNAMES: ClassNames;
+export declare const DEFAULT_CONFIG: Options;

data/node_modules/choices.js/public/types/src/scripts/interfaces/action-type.d.ts

@@ -0,0 +1,13 @@
+import { Types } from './types';
+export declare const ActionType: {
+    readonly ADD_CHOICE: "ADD_CHOICE";
+    readonly REMOVE_CHOICE: "REMOVE_CHOICE";
+    readonly FILTER_CHOICES: "FILTER_CHOICES";
+    readonly ACTIVATE_CHOICES: "ACTIVATE_CHOICES";
+    readonly CLEAR_CHOICES: "CLEAR_CHOICES";
+    readonly ADD_GROUP: "ADD_GROUP";
+    readonly ADD_ITEM: "ADD_ITEM";
+    readonly REMOVE_ITEM: "REMOVE_ITEM";
+    readonly HIGHLIGHT_ITEM: "HIGHLIGHT_ITEM";
+};
+export type ActionTypes = Types.ValueOf<typeof ActionType>;

data/node_modules/choices.js/public/types/src/scripts/interfaces/build-flags.d.ts

@@ -0,0 +1,11 @@
+export declare const canUseDom: boolean;
+export declare const searchFuse: string | undefined;
+export declare const searchKMP: boolean;
+/**
+ * These are not directly used, as an exported object (even as const) will prevent tree-shake away code paths
+ */
+export declare const BuildFlags: {
+    readonly searchFuse: string | undefined;
+    readonly searchKMP: boolean;
+    readonly canUseDom: boolean;
+};

data/node_modules/choices.js/public/types/src/scripts/interfaces/choice-full.d.ts

@@ -0,0 +1,23 @@
+import { StringUntrusted } from './string-untrusted';
+import { Types } from './types';
+import { GroupFull } from './group-full';
+export interface ChoiceFull {
+    id: number;
+    highlighted: boolean;
+    element?: HTMLOptionElement | HTMLOptGroupElement;
+    itemEl?: HTMLElement;
+    choiceEl?: HTMLElement;
+    labelClass?: Array<string>;
+    labelDescription?: string;
+    customProperties?: Types.CustomProperties;
+    disabled: boolean;
+    active: boolean;
+    elementId?: string;
+    group: GroupFull | null;
+    label: StringUntrusted | string;
+    placeholder: boolean;
+    selected: boolean;
+    value: string;
+    score: number;
+    rank: number;
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/class-names.d.ts

@@ -0,0 +1,61 @@
+/** Classes added to HTML generated by  By default classnames follow the BEM notation. */
+export interface ClassNames {
+    /** @default ['choices'] */
+    containerOuter: string | Array<string>;
+    /** @default ['choices__inner'] */
+    containerInner: string | Array<string>;
+    /** @default ['choices__input'] */
+    input: string | Array<string>;
+    /** @default ['choices__input--cloned'] */
+    inputCloned: string | Array<string>;
+    /** @default ['choices__list'] */
+    list: string | Array<string>;
+    /** @default ['choices__list--multiple'] */
+    listItems: string | Array<string>;
+    /** @default ['choices__list--single'] */
+    listSingle: string | Array<string>;
+    /** @default ['choices__list--dropdown'] */
+    listDropdown: string | Array<string>;
+    /** @default ['choices__item'] */
+    item: string | Array<string>;
+    /** @default ['choices__item--selectable'] */
+    itemSelectable: string | Array<string>;
+    /** @default ['choices__item--disabled'] */
+    itemDisabled: string | Array<string>;
+    /** @default ['choices__item--choice'] */
+    itemChoice: string | Array<string>;
+    /** @default ['choices__description'] */
+    description: string | Array<string>;
+    /** @default ['choices__placeholder'] */
+    placeholder: string | Array<string>;
+    /** @default ['choices__group'] */
+    group: string | Array<string>;
+    /** @default ['choices__heading'] */
+    groupHeading: string | Array<string>;
+    /** @default ['choices__button'] */
+    button: string | Array<string>;
+    /** @default ['is-active'] */
+    activeState: string | Array<string>;
+    /** @default ['is-focused'] */
+    focusState: string | Array<string>;
+    /** @default ['is-open'] */
+    openState: string | Array<string>;
+    /** @default ['is-disabled'] */
+    disabledState: string | Array<string>;
+    /** @default ['is-highlighted'] */
+    highlightedState: string | Array<string>;
+    /** @default ['is-selected'] */
+    selectedState: string | Array<string>;
+    /** @default ['is-flipped'] */
+    flippedState: string | Array<string>;
+    /** @default ['is-loading'] */
+    loadingState: string | Array<string>;
+    /** @default ['choices__notice'] */
+    notice: string | Array<string>;
+    /** @default ['choices__item--selectable', 'add-choice'] */
+    addChoice: string | Array<string>;
+    /** @default ['has-no-results'] */
+    noResults: string | Array<string>;
+    /** @default ['has-no-choices'] */
+    noChoices: string | Array<string>;
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/event-choice.d.ts

@@ -0,0 +1,7 @@
+import { InputChoice } from './input-choice';
+export type EventChoiceValueType<B extends boolean> = B extends true ? string : EventChoice;
+export interface EventChoice extends InputChoice {
+    element?: HTMLOptionElement | HTMLOptGroupElement;
+    groupValue?: string;
+    keyCode?: number;
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/event-type.d.ts

@@ -0,0 +1,14 @@
+import { Types } from './types';
+export declare const EventType: {
+    readonly showDropdown: "showDropdown";
+    readonly hideDropdown: "hideDropdown";
+    readonly change: "change";
+    readonly choice: "choice";
+    readonly search: "search";
+    readonly addItem: "addItem";
+    readonly removeItem: "removeItem";
+    readonly highlightItem: "highlightItem";
+    readonly highlightChoice: "highlightChoice";
+    readonly unhighlightItem: "unhighlightItem";
+};
+export type EventTypes = Types.ValueOf<typeof EventType>;

data/node_modules/choices.js/public/types/src/scripts/interfaces/group-full.d.ts

@@ -0,0 +1,10 @@
+import { ChoiceFull } from './choice-full';
+export interface GroupFull {
+    id: number;
+    active: boolean;
+    disabled: boolean;
+    label?: string;
+    element?: HTMLOptGroupElement;
+    groupEl?: HTMLElement;
+    choices: ChoiceFull[];
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/index.d.ts

@@ -0,0 +1,14 @@
+export * from './action-type';
+export * from './input-choice';
+export * from './input-group';
+export * from './event-choice';
+export * from './class-names';
+export * from './event-type';
+export * from './item';
+export * from './keycode-map';
+export * from './options';
+export * from './passed-element';
+export * from './passed-element-type';
+export * from './position-options-type';
+export * from './state';
+export * from './types';

data/node_modules/choices.js/public/types/src/scripts/interfaces/input-choice.d.ts

@@ -0,0 +1,15 @@
+import { StringUntrusted } from './string-untrusted';
+import { Types } from './types';
+export interface InputChoice {
+    id?: number;
+    highlighted?: boolean;
+    labelClass?: string | Array<string>;
+    labelDescription?: string;
+    customProperties?: Types.CustomProperties;
+    disabled?: boolean;
+    active?: boolean;
+    label: StringUntrusted | string;
+    placeholder?: boolean;
+    selected?: boolean;
+    value: any;
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/input-group.d.ts

@@ -0,0 +1,10 @@
+import { InputChoice } from './input-choice';
+import { StringUntrusted } from './string-untrusted';
+export interface InputGroup {
+    id?: number;
+    active?: boolean;
+    disabled?: boolean;
+    label?: StringUntrusted | string;
+    value: string;
+    choices: InputChoice[];
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/item.d.ts

@@ -0,0 +1,17 @@
+import { InputChoice } from './input-choice';
+import { InputGroup } from './input-group';
+/**
+ * @deprecated Use InputChoice instead
+ */
+export interface Item extends InputChoice {
+}
+/**
+ * @deprecated Use InputChoice instead
+ */
+export interface Choice extends InputChoice {
+}
+/**
+ * @deprecated Use InputGroup instead
+ */
+export interface Group extends InputGroup {
+}

data/node_modules/choices.js/public/types/src/scripts/interfaces/keycode-map.d.ts

@@ -0,0 +1,13 @@
+export declare const KeyCodeMap: {
+    readonly TAB_KEY: 9;
+    readonly SHIFT_KEY: 16;
+    readonly BACK_KEY: 46;
+    readonly DELETE_KEY: 8;
+    readonly ENTER_KEY: 13;
+    readonly A_KEY: 65;
+    readonly ESC_KEY: 27;
+    readonly UP_KEY: 38;
+    readonly DOWN_KEY: 40;
+    readonly PAGE_UP_KEY: 33;
+    readonly PAGE_DOWN_KEY: 34;
+};