@lion/ui 0.20.0 → 0.21.0

package/docs/components/input-datepicker/overview.md

@@ -14,7 +14,7 @@ eleventyNavigation:
 
 A web component based on the date text input field. Its purpose is to provide a way for users to fill in a date with a datepicker.
 For an input field with a big range, such as `birthday-input`, a datepicker is not the best choice due to the high variance between possible inputs.
-We encourage using our standard [input-date](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-date/overview.md) for this.
+We encourage using our standard [input-date](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-date/overview.md) for this.
 
 ```js script
 import { html } from '@mdjs/mdjs-preview';
@@ -30,11 +30,11 @@ export const main = () => {
 ## Features
 
 - Input field with a datepicker to help to choose a date
-- Based on our [input-date](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-date/overview.md)
-- Makes use of our [calendar](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/calendar/overview.md) inside the datepicker
-- Makes use of [formatDate](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/fundamentals/systems/localize/dates.md) for formatting and parsing.
+- Based on our [input-date](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-date/overview.md)
+- Makes use of our [calendar](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/calendar/overview.md) inside the datepicker
+- Makes use of [formatDate](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/fundamentals/systems/localize/dates.md) for formatting and parsing.
 - Option to overwrite locale to change the formatting and parsing
-- Can make use of date specific [validators](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/fundamentals/systems/form/validate.md) with corresponding error messages in different languages
+- Can make use of date specific [validators](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/fundamentals/systems/form/validate.md) with corresponding error messages in different languages
   - IsDate (default)
   - MinDate
   - MaxDate

package/docs/components/input-email/api-table.md

@@ -62,6 +62,7 @@ eleventyNavigation:
 | `_helpTextNode`              | protected |                                           |                         | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputId`                   | protected | `string`                                  |                         | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                         | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField            |
+| `_isEditingTextField`        | protected |                                           |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField            |
 | `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                 | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | LionField            |
 | `_isPasting`                 | protected | `boolean`                                 | `false`                 | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | LionField            |
 | `_isRepropagationEndpoint`   | public    | `boolean`                                 | `false`                 | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                      | LionField            |
@@ -92,7 +93,7 @@ eleventyNavigation:
 | `initInteractionState`                   | public    | Evaluations performed on connectedCallback.
This method is public, so it can be called at a later moment (when we need to wait for
registering children for instance) as well.
Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField            |
 | `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField            |
 | `parser`                                 | public    | Converts viewValue to modelValue
For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `v: string, opts: FormatOptions`                                                                               | `*`                                                           | LionField            |
-| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessro that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField            |
+| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessor that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField            |
 | `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | LionField            |
 | `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | LionField            |
 | `reset`                                  | public    | Resets modelValue to initial value.
Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField            |

package/docs/components/input-email/overview.md

@@ -27,8 +27,8 @@ export const main = () => {
 
 ## Features
 
-- Based on our [input](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input/overview.md)
-- Makes use of email [validators](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/fundamentals/systems/form/validate.md) with corresponding error messages in different languages
+- Based on our [input](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input/overview.md)
+- Makes use of email [validators](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/fundamentals/systems/form/validate.md) with corresponding error messages in different languages
   - IsEmail (default)
 
 ## Installation

package/docs/components/input-file/api-table.md

@@ -92,6 +92,7 @@ eleventyNavigation:
 | `_inputId`                   | protected | `string`                              |                         | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField      |
 | `_inputNode`                 | protected | `HTMLInputElement`                    |                         | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField      |
 | `_isDragAndDropSupported`    | protected |                                       |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                |
+| `_isEditingTextField`        | protected |                                       |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField      |
 | `_isHandlingUserInput`       | protected | `boolean`                             | `false`                 | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | LionField      |
 | `_isPasting`                 | protected | `boolean`                             | `false`                 | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | LionField      |
 | `_isRepropagationEndpoint`   | public    | `boolean`                             | `false`                 | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                      | LionField      |
@@ -123,7 +124,7 @@ eleventyNavigation:
 | `initInteractionState`                   | public    | Evaluations performed on connectedCallback.
This method is public, so it can be called at a later moment (when we need to wait for
registering children for instance) as well.
Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField      |
 | `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField      |
 | `parser`                                 | public    | Converts viewValue to modelValue
For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `v: string, opts: FormatOptions`                                                                               | `InputFile[]`                                                 | LionField      |
-| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessro that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField      |
+| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessor that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField      |
 | `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | LionField      |
 | `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | LionField      |
 | `reset`                                  | public    | Resets modelValue to initial value.
Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField      |

package/docs/components/input-file/overview.md

@@ -27,7 +27,7 @@ export const main = () => {
 
 ## Features
 
-- Based on our [input](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input/overview.md)
+- Based on our [input](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input/overview.md)
 - Default labels and validation messages in different languages
 - Options for multi file upload and drop-zone.
 

package/docs/components/input-iban/api-table.md

@@ -64,6 +64,7 @@ eleventyNavigation:
 | `_helpTextNode`              | protected |                                           |                         | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputId`                   | protected | `string`                                  |                         | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                         | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField            |
+| `_isEditingTextField`        | protected |                                           |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField            |
 | `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                 | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | LionField            |
 | `_isPasting`                 | protected | `boolean`                                 | `false`                 | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | LionField            |
 | `_isRepropagationEndpoint`   | public    | `boolean`                                 | `false`                 | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                      | LionField            |
@@ -92,7 +93,7 @@ eleventyNavigation:
 | `focus`                                  | public    | Calls \`focus()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                                                               | LionField            |
 | `initInteractionState`                   | public    | Evaluations performed on connectedCallback.
This method is public, so it can be called at a later moment (when we need to wait for
registering children for instance) as well.
Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField            |
 | `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField            |
-| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessro that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField            |
+| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessor that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField            |
 | `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | LionField            |
 | `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | LionField            |
 | `reset`                                  | public    | Resets modelValue to initial value.
Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField            |

package/docs/components/input-iban/overview.md

@@ -28,9 +28,9 @@ export const main = () => {
 
 ## Features
 
-- Based on our [input](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input/overview.md)
+- Based on our [input](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input/overview.md)
 - Default label in different languages
-- Makes use of IBAN specific [validate](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/fundamentals/systems/form/validate.md) with corresponding error messages in different languages
+- Makes use of IBAN specific [validate](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/fundamentals/systems/form/validate.md) with corresponding error messages in different languages
   - IsIBAN (default)
   - IsCountryIBAN
 - Parses IBANs automatically

package/docs/components/input-range/api-table.md

@@ -37,7 +37,9 @@ eleventyNavigation:
 | `label`                      | public    | `string`                                  |                                    | The label text for the input node.
When no light dom defined via \[slot=label], this value will be used.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | LionField            |
 | `labelSrOnly`                | public    | `boolean`                                 | `false`                            | The label will only be visible for srceen readers when true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `max`                        | public    | `number`                                  | `Infinity`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                      |
+| `maxLabel`                   | public    | `string`                                  | `''`                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                      |
 | `min`                        | public    | `number`                                  | `Infinity`                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                      |
+| `minLabel`                   | public    | `string`                                  | `''`                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                      |
 | `modelValue`                 | public    |                                           |                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField            |
 | `name`                       | public    | `string`                                  | `''`                               | The name the element will be registered with to the .formElements collection
of the parent. Also, it serves as the key of key/value pairs in
 modelValue/serializedValue objects                                                                                                                                                                                                                                                                                                                                                                                                                  | LionField            |
 | `noMinMaxLabels`             | public    | `boolean`                                 | `false`                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                      |
@@ -69,6 +71,7 @@ eleventyNavigation:
 | `_helpTextNode`              | protected |                                           |                                    | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputId`                   | protected | `string`                                  |                                    | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                                    | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField            |
+| `_isEditingTextField`        | protected |                                           |                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField            |
 | `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                            | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | LionField            |
 | `_isPasting`                 | protected | `boolean`                                 | `false`                            | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | LionField            |
 | `_isRepropagationEndpoint`   | public    | `boolean`                                 | `false`                            | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                      | LionField            |
@@ -78,6 +81,7 @@ eleventyNavigation:
 | `_repropagationRole`         | public    | `'child'\|'choice-group'\|'fieldset'`     | `'child'`                          | Based on the role, details of handling model-value-changed repropagation differ.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | LionField            |
 | `_requestedToBeDisabled`     | protected | `boolean`                                 | `false`                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField            |
 | `_valueChangedEvent`         | protected | `string`                                  | `'model-value-changed'`            | The event that triggers the dirty state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField            |
+| `_valueDisplay`              | protected |                                           |                                    | Get the display info for the current value                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |                      |
 | `_visibleMessagesAmount`     | protected | `number`                                  | `1`                                | The amount of feedback messages that will visible in LionValidationFeedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 
 ### Methods
@@ -98,7 +102,7 @@ eleventyNavigation:
 | `formatter`                              | public    | Converts modelValue to formattedValue (formattedValue will be synced with
\`.\_inputNode.value\`)
For instance, a Date object to a localized date.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `v: *, opts: FormatOptions`                                                                                    | `string`                                                      | LionField            |
 | `initInteractionState`                   | public    | Evaluations performed on connectedCallback.
This method is public, so it can be called at a later moment (when we need to wait for
registering children for instance) as well.
Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField            |
 | `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField            |
-| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessro that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField            |
+| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessor that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField            |
 | `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | LionField            |
 | `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | LionField            |
 | `reset`                                  | public    | Resets modelValue to initial value.
Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField            |
@@ -179,6 +183,8 @@ eleventyNavigation:
 | `unit`                          | unit                       |                      |
 | `step`                          | step                       |                      |
 | `no-min-max-labels`             | noMinMaxLabels             |                      |
+| `min-label`                     | minLabel                   |                      |
+| `max-label`                     | maxLabel                   |                      |
 | `autocomplete`                  | autocomplete               | NativeTextFieldMixin |
 | `focused`                       | focused                    | LionField            |
 | `focused-visible`               | focusedVisible             | LionField            |

package/docs/components/input-range/overview.md

@@ -25,11 +25,11 @@ import '@lion/ui/define/lion-input-range.js';
 
 ## Features
 
-- Based on our [input](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input/overview.md).
+- Based on our [input](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input/overview.md).
 - Shows `modelValue` and `unit` above the range input.
 - Shows `min` and `max` value after the range input.
 - Can hide the `min` and `max` value via `no-min-max-labels`.
-- Makes use of [formatNumber](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/fundamentals/systems/localize/numbers.md) for formatting and parsing.
+- Makes use of [formatNumber](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/fundamentals/systems/localize/numbers.md) for formatting and parsing.
 
 ## Installation
 

package/docs/components/input-range/use-cases.md

@@ -60,6 +60,20 @@ import '@lion/ui/define/lion-input-range.js';
 ></lion-input-range>
 ```
 
+## Custom Min Max Labels
+
+```html preview-story
+<lion-input-range
+  min="0"
+  max="11"
+  min-label="less than 1 item"
+  max-label="more than 10 items"
+  .modelValue="${4}"
+  unit="Items"
+  label="Items"
+></lion-input-range>
+```
+
 ## Disabled
 
 ```html preview-story

package/docs/components/input-stepper/api-table.md

@@ -70,6 +70,7 @@ eleventyNavigation:
 | `_helpTextNode`              | protected |                                           |                                                      | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputId`                   | protected | `string`                                  |                                                      | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                                                      | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField            |
+| `_isEditingTextField`        | protected |                                           |                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField            |
 | `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                                              | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | LionField            |
 | `_isPasting`                 | protected | `boolean`                                 | `false`                                              | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | LionField            |
 | `_isRepropagationEndpoint`   | public    | `boolean`                                 | `false`                                              | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                      | LionField            |
@@ -98,7 +99,7 @@ eleventyNavigation:
 | `focus`                                  | public    | Calls \`focus()\` on focusable element within                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |                                                                                                                |                                                               | LionField            |
 | `initInteractionState`                   | public    | Evaluations performed on connectedCallback.
This method is public, so it can be called at a later moment (when we need to wait for
registering children for instance) as well.
Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField            |
 | `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                |                                                               | LionField            |
-| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessro that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField            |
+| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessor that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `v: string, opts: FormatOptions & { prevViewValue: string; currentCaretIndex: number }`                        | `{ viewValue:string; caretIndex:number; }\|string\|undefined` | LionField            |
 | `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                         |                                                               | LionField            |
 | `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                         |                                                               | LionField            |
 | `reset`                                  | public    | Resets modelValue to initial value.
Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                |                                                               | LionField            |

package/docs/components/input-stepper/overview.md

@@ -30,7 +30,7 @@ loadDefaultFeedbackMessages();
 
 ## Features
 
-- Based on our [input](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input/overview.md).
+- Based on our [input](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input/overview.md).
 - Set `min` and `max` value to define the range.
 - Set `step` value in integer or decimal to increase and decrease the value.
 - Use `ArrowUp` or `ArrowDown` to update the value.

package/docs/components/input-tel/api-table.md

@@ -69,6 +69,7 @@ eleventyNavigation:
 | `_helpTextNode`              | protected |                                           |                         | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputId`                   | protected | `string`                                  |                         | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | LionField            |
 | `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                         | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField            |
+| `_isEditingTextField`        | protected |                                           |                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | LionField            |
 | `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                 | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                         | LionField            |
 | `_isPasting`                 | protected | `boolean`                                 | `false`                 | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | LionField            |
 | `_isRepropagationEndpoint`   | public    | `boolean`                                 | `false`                 | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                      | LionField            |
@@ -101,7 +102,7 @@ eleventyNavigation:
 | `initInteractionState`                   | public    | Evaluations performed on connectedCallback.
This method is public, so it can be called at a later moment (when we need to wait for
registering children for instance) as well.
Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                |                                                           | LionField            |
 | `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                |                                                           | LionField            |
 | `parser`                                 | public    | Converts viewValue to modelValue
For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `viewValue: string`                                                                                                                                            | `string`                                                  | LionField            |
-| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessro that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `viewValue: string, { currentCaretIndex, prevViewValue }, options: @param {string} options.prevViewValue    * @param {number} options.currentCaretIndex    * ` | `{ viewValue: string; caretIndex: number; } \| undefined` | LionField            |
+| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessor that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `viewValue: string, { currentCaretIndex, prevViewValue }, options: @param {string} options.prevViewValue    * @param {number} options.currentCaretIndex    * ` | `{ viewValue: string; caretIndex: number; } \| undefined` | LionField            |
 | `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                                                                         |                                                           | LionField            |
 | `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                                                                         |                                                           | LionField            |
 | `reset`                                  | public    | Resets modelValue to initial value.
Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                |                                                           | LionField            |

package/docs/components/input-tel/overview.md

@@ -51,7 +51,7 @@ export const main = () => {
 
 ## Features
 
-- Extends our [input](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input/overview.md)
+- Extends our [input](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input/overview.md)
 - Shows a mobile telephone keypad on mobile (by having a native `<input inputmode="tel">` inside)
 - Can be configured with a list of allowed region codes
 - Will be preconfigured with region derived from locale

package/docs/components/input-tel/use-cases.md

@@ -34,7 +34,7 @@ Say we have the following telephone number from Madrid, Spain: `+34919930432`.
 It contains a [country code](https://en.wikipedia.org/wiki/Country_code) (34), an [area code](https://en.wikipedia.org/wiki/Telephone_numbering_plan#Area_code) (91) and a [dial code](https://en.wikipedia.org/wiki/Mobile_dial_code) (+34 91).
 Input Tel interprets phone numbers based on their [region code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2): a two character long region representation('ES' in the telephone number above).
 
-The table below lists all possible regions worldwide. When [allowed regions](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-tel/#allowed-regions) are not configured,
+The table below lists all possible regions worldwide. When [allowed regions](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-tel/#allowed-regions) are not configured,
 all of them will be supported as values of Input Tel.
 
 ```js story
@@ -49,11 +49,11 @@ export const regionCodesTable = () => {
 The active region (accessible via readonly accessor `.activeRegion`) determines how validation and formatting
 should be applied. It is dependent on the following factors:
 
-- [allowed regions](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-tel/#allowed-regions): a list that determines what is allowed to become .activeRegion. If
-  [.allowedRegions has only one entry](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-tel/#restrict-to-one-region), .activeRegion will always be this value.
+- [allowed regions](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-tel/#allowed-regions): a list that determines what is allowed to become .activeRegion. If
+  [.allowedRegions has only one entry](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-tel/#restrict-to-one-region), .activeRegion will always be this value.
 - the modelValue or viewValue: once it contains sufficient info to derive its region code (and
-  the derived code is inside [allowed regions](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-tel/#allowed-regions) if configured)
-- active locale (and the derived locale is inside [allowed regions](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-tel/#allowed-regions) if configured)
+  the derived code is inside [allowed regions](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-tel/#allowed-regions) if configured)
+- active locale (and the derived locale is inside [allowed regions](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-tel/#allowed-regions) if configured)
 
 What follows from the list above is that .activeRegion can change dynamically, after a value
 change in the text box by the user (or when locales or allowed regions would be changed by the
@@ -142,7 +142,7 @@ export const heuristic = () => {
 Once it is configured, validation and formatting will be restricted to those
 values that are present in this list.
 
-> Note that for [InputTelDropdown](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-tel-dropdown/index.md), only allowed regions will
+> Note that for [InputTelDropdown](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-tel-dropdown/index.md), only allowed regions will
 > be shown in the dropdown list.
 
 ```js preview-story

package/docs/components/input-tel-dropdown/api-table.md

@@ -71,6 +71,7 @@ eleventyNavigation:
 | `_helpTextNode`              | protected |                                           |                                                                                      | Element where help text will be rendered to                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | LionField            |
 | `_inputId`                   | protected | `string`                                  |                                                                                      | Unique id that can be used in all light dom                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | LionField            |
 | `_inputNode`                 | protected | `HTMLInputElement \| HTMLTextAreaElement` |                                                                                      | The interactive (form) element. Can be a native element like input/textarea/select or
an element with tabindex > -1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | LionField            |
+| `_isEditingTextField`        | protected |                                           |                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | LionField            |
 | `_isHandlingUserInput`       | protected | `boolean`                                 | `false`                                                                              | Flag that will be set when user interaction takes place (for instance after an 'input'
event). Will be added as meta info to the \`model-value-changed\` event. Depending on
whether a user is interacting, formatting logic will be handled differently.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | LionField            |
 | `_isPasting`                 | protected | `boolean`                                 | `false`                                                                              | Whether the user is pasting content. Allows Subclassers to do this in their subclass:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | LionField            |
 | `_isRepropagationEndpoint`   | public    | `boolean`                                 | `false`                                                                              | By default, a field with \_repropagationRole 'choice-group' will act as an
'endpoint'. This means it will be considered as an individual field: for
a select, individual options will not be part of the formPath. They
will.
Similarly, components that (a11y wise) need to be fieldsets, but 'interaction wise'
(from Application Developer perspective) need to be more like fields
(think of an amount-input with a currency select box next to it), can set this
to true to hide private internals in the formPath.                                                                                                                                                                                                                                                                                                                                    | LionField            |
@@ -105,7 +106,7 @@ eleventyNavigation:
 | `initInteractionState`                   | public    | Evaluations performed on connectedCallback.
This method is public, so it can be called at a later moment (when we need to wait for
registering children for instance) as well.
Since this method will be called twice in last mentioned scenario, it must stay idempotent.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                |                                                           | LionField            |
 | `makeRequestToBeDisabled`                | public    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |                                                                                                                                                                |                                                           | LionField            |
 | `parser`                                 | public    | Converts viewValue to modelValue
For instance, a localized date to a Date Object                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `viewValue: string`                                                                                                                                            | `string`                                                  | LionField            |
-| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessro that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `viewValue: string, { currentCaretIndex, prevViewValue }, options: @param {string} options.prevViewValue    * @param {number} options.currentCaretIndex    * ` | `{ viewValue: string; caretIndex: number; } \| undefined` | LionField            |
+| `preprocessor`                           | public    | Preprocessors could be considered 'live formatters'. Their result is shown to the user
on keyup instead of after blurring the field. The biggest difference between preprocessors
and formatters is their moment of execution: preprocessors are run before modelValue is
computed (and work based on view value), whereas formatters are run after the parser (and
are based on modelValue)
Automatically formats code while typing. It depends on a preprocessor that smartly
updates the viewValue and caret position for best UX.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `viewValue: string, { currentCaretIndex, prevViewValue }, options: @param {string} options.prevViewValue    * @param {number} options.currentCaretIndex    * ` | `{ viewValue: string; caretIndex: number; } \| undefined` | LionField            |
 | `removeFromAriaDescribedBy`              | public    | Allows to remove element references from aria-describedby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | `element: HTMLElement`                                                                                                                                         |                                                           | LionField            |
 | `removeFromAriaLabelledBy`               | public    | Allows to remove element references from aria-labelledby attribute.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `element: HTMLElement`                                                                                                                                         |                                                           | LionField            |
 | `reset`                                  | public    | Resets modelValue to initial value.
Interaction states are cleared                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |                                                                                                                                                                |                                                           | LionField            |

package/docs/components/input-tel-dropdown/overview.md

@@ -31,7 +31,7 @@ export const main = () => {
 
 ## Features
 
-- Extends our [input-tel](https://github.com/ing-bank/lion/blob/f772d573181b73001438c110f2efa18bd3281d1c/docs/components/input-tel/overview.md)
+- Extends our [input-tel](https://github.com/ing-bank/lion/blob/5c228561a361a8ed95aabcacf735f87fb2746a5f/docs/components/input-tel/overview.md)
 - Shows dropdown list with all possible regions
 - Shows only allowed regions in dropdown list when .allowedRegions is configured
 - Highlights regions on top of dropdown list when .preferredRegions is configured