@descope/web-components-ui 1.0.51 → 1.0.53

package/dist/index.esm.js

@@ -5,6 +5,7 @@ import '@vaadin/email-field';
 import '@vaadin/password-field';
 import '@vaadin/text-area';
 import '@vaadin/date-picker';
+import '@vaadin/checkbox';
 import merge from 'lodash.merge';
 import set from 'lodash.set';
 import Color from 'color';
@@ -108,80 +109,111 @@ const matchHostStyle = (mappingObj = {}) => [
 ];
 
 const createStyleMixin =
-	({ mappings = {} }) =>
-	(superclass) => {
-		const styleAttributes = Object.keys(mappings).map((key) =>
-			kebabCaseJoin('st', key)
-		);
-		return class CustomStyleMixinClass extends superclass {
-			static get observedAttributes() {
-				const superAttrs = superclass.observedAttributes || [];
-				return [...superAttrs, ...styleAttributes];
-			}
+	({ mappings = {}, nestedMappings = {} }) =>
+		(superclass) => {
+			const styleAttributes = Object.keys(mappings).map((key) =>
+				kebabCaseJoin('st', key)
+			);
+			return class CustomStyleMixinClass extends superclass {
+				static get observedAttributes() {
+					const superAttrs = superclass.observedAttributes || [];
+					return [...superAttrs, ...styleAttributes];
+				}
 
-			static get cssVarList() {
-				return createCssVarsList(superclass.componentName, mappings);
-			}
+				static get cssVarList() {
+					return createCssVarsList(superclass.componentName, mappings);
+				}
 
-			#styleEle = null;
+				#styleEle = null;
 
-			constructor() {
-				super();
+				constructor() {
+					super();
 
-				this.#createComponentStyle();
-				this.#createAttrOverrideStyle();
-			}
+					this.#createComponentStyle();
+					this.#createAttrOverrideStyle();
+				}
 
-			#createAttrOverrideStyle() {
-				this.#styleEle = document.createElement('style');
-				this.#styleEle.id = 'style-mixin-overrides';
+				#createAttrOverrideStyle() {
+					this.#styleEle = document.createElement('style');
+					this.#styleEle.id = 'style-mixin-overrides';
 
-				this.#styleEle.innerText = '* {}';
-				this.shadowRoot.prepend(this.#styleEle);
-			}
+					this.#styleEle.innerText = '* {}';
+					this.shadowRoot.prepend(this.#styleEle);
+				}
 
-			#updateAttrOverrideStyle(attrName, value) {
-				const style = this.#styleEle.sheet.cssRules[0].style;
-				const varName = getCssVarName(
-					superclass.componentName,
-					attrName.replace(/^st-/, '')
-				);
+				#updateAttrOverrideStyle(attrName, value) {
+					const style = this.#styleEle.sheet?.cssRules[0].style;
+					const varName = getCssVarName(
+						superclass.componentName,
+						attrName.replace(/^st-/, '')
+					);
 
-				if (value) style.setProperty(varName, value);
-				else style.removeProperty(varName);
-			}
+					if (value) style?.setProperty(varName, value);
+					else style?.removeProperty(varName);
+				}
 
-			#createComponentStyle() {
-				const themeStyle = document.createElement('style');
-				themeStyle.id = 'style-mixin-component';
-				themeStyle.innerHTML = createStyle(
-					superclass.componentName,
-					this.baseSelector,
-					mappings
-				);
-				this.shadowRoot.prepend(themeStyle);
-			}
+				#createComponentStyle() {
+					const themeStyle = document.createElement('style');
+					themeStyle.id = 'style-mixin-component';
+					themeStyle.innerHTML = createStyle(
+						superclass.componentName,
+						this.baseSelector,
+						mappings
+					);
+					this.shadowRoot.prepend(themeStyle);
+				}
+
+				#createComponentNestingStyle() {
+					// we need these selectors to be more specific from the theme selectors
+					// in order to do it, we are repeating the class name for specificity
+					const numOfClassNameSpecifier = 3;
+
+					const rootNode = this.shadowRoot.host.getRootNode();
+					const styleId = `${superclass.componentName}-style-mixin-component`;
+
+					const className = superclass.componentName;
+					this.shadowRoot.host.classList.add(className);
 
-			attributeChangedCallback(attrName, oldValue, newValue) {
-				super.attributeChangedCallback?.(attrName, oldValue, newValue);
+					if(rootNode.querySelector(`style#${styleId}`)) return;
 
-				if (styleAttributes.includes(attrName)) {
-					this.#updateAttrOverrideStyle(attrName, newValue);
+					const themeStyle = document.createElement('style');
+					themeStyle.id = styleId;
+					themeStyle.innerHTML = createStyle(
+						superclass.componentName,
+						`${superclass.componentName}${Array(numOfClassNameSpecifier).fill(`.${className}`).join('')}`,
+						nestedMappings
+					);
+
+					// rootNode can be either a shadow DOM or a light DOM
+					if (rootNode.nodeName === '#document') {
+						rootNode.head.append(themeStyle);
+					} else {
+						rootNode.append(themeStyle);
+					}
 				}
-			}
 
-    connectedCallback() {
-      super.connectedCallback?.();
-      if (this.shadowRoot.isConnected) {
-        Array.from(this.attributes).forEach(attr => {
-          if (styleAttributes.includes(attr.nodeName)) {
-            this.#updateAttrOverrideStyle(attr.nodeName, attr.value);
-          }
-        });
-      }
-    }
+				attributeChangedCallback(attrName, oldValue, newValue) {
+					super.attributeChangedCallback?.(attrName, oldValue, newValue);
+
+					if (styleAttributes.includes(attrName)) {
+						this.#updateAttrOverrideStyle(attrName, newValue);
+					}
+				}
+
+				connectedCallback() {
+					super.connectedCallback?.();
+					if (this.shadowRoot.isConnected) {
+						this.#createComponentNestingStyle();
+
+						Array.from(this.attributes).forEach(attr => {
+							if (styleAttributes.includes(attr.nodeName)) {
+								this.#updateAttrOverrideStyle(attr.nodeName, attr.value);
+							}
+						});
+					}
+				}
+			};
 		};
-	};
 
 const draggableMixin = (superclass) =>
 	class DraggableMixinClass extends superclass {
@@ -215,17 +247,32 @@ const draggableMixin = (superclass) =>
 		}
 	};
 
-const observeAttributes = (ele, callback, excludeAttrs) => {
+class DescopeBaseClass extends HTMLElement {}
+
+const observeAttributes = (
+	ele,
+	callback,
+	{ excludeAttrs = [], includeAttrs = [] }
+) => {
 	// sync all attrs on init
-	callback(...Array.from(ele.attributes).map((attr) => attr.name));
+	callback(
+		...Array.from(ele.attributes)
+			.filter(
+				(attr) =>
+					!excludeAttrs.includes(attr.name) &&
+					(!includeAttrs.length || includeAttrs.includes(attr.name))
+			)
+			.map((attr) => attr.name)
+	);
 
 	const observer = new MutationObserver((mutationsList) => {
 		for (const mutation of mutationsList) {
 			if (
 				mutation.type === 'attributes' &&
-				!excludeAttrs.includes(mutation.attributeName)
+				!excludeAttrs.includes(mutation.attributeName) &&
+				(!includeAttrs.length || includeAttrs.includes(attr.name))
 			) {
-				callback(mutation.attributeName);
+				callback([mutation.attributeName]);
 			}
 		}
 	});
@@ -248,9 +295,13 @@ const createSyncAttrsCb =
 		});
 	};
 
-const syncAttrs = (ele1, ele2, excludeAttrs) => {
-	observeAttributes(ele1, createSyncAttrsCb(ele1, ele2), excludeAttrs);
-	observeAttributes(ele2, createSyncAttrsCb(ele2, ele1), excludeAttrs);
+const syncAttrs = (ele1, ele2, options) => {
+	observeAttributes(ele1, createSyncAttrsCb(ele1, ele2), options);
+	observeAttributes(ele2, createSyncAttrsCb(ele2, ele1), options);
+};
+
+const forwardAttrs = (source, dest, options) => {
+	observeAttributes(source, createSyncAttrsCb(source, dest), options);
 };
 
 const createProxy = ({
@@ -268,7 +319,7 @@ const createProxy = ({
 		</${wrappedEleName}>
 	`;
 
-	class ProxyElement extends HTMLElement {
+	class ProxyElement extends DescopeBaseClass {
 		static get componentName() {
 			return componentName;
 		}
@@ -276,7 +327,6 @@ const createProxy = ({
 		constructor() {
 			super().attachShadow({ mode: 'open' }).innerHTML = template;
 			this.hostElement = this.shadowRoot.host;
-			this.componentName = this.hostElement.tagName.toLowerCase();
 			this.baseSelector = wrappedEleName;
 			this.shadowRoot.getElementById('create-proxy').innerHTML =
 				typeof style === 'function' ? style() : style;
@@ -288,9 +338,9 @@ const createProxy = ({
 				this.setAttribute('tabindex', '0');
 
 				// we want to focus on the proxy element when focusing our WC
-				this.onfocus = (e) => {
+				this.addEventListener('focus', () => {
 					this.proxyElement.focus();
-				};
+				});
 
 				// `onkeydown` is set on `proxyElement` support proper tab-index navigation
 				// this support is needed since both proxy host and element catch `focus`/`blur` event
@@ -316,9 +366,11 @@ const createProxy = ({
 				this.proxyElement.addEventListener('mouseover', this.mouseoverCbRef);
 
 				// sync events
-				this.addEventListener = this.proxyElement.addEventListener;
+				this.addEventListener = (...args) => this.proxyElement.addEventListener(...args);
 
-				syncAttrs(this.proxyElement, this.hostElement, excludeAttrsSync);
+				syncAttrs(this.proxyElement, this.hostElement, {
+					excludeAttrs: excludeAttrsSync
+				});
 			}
 		}
 
@@ -392,40 +444,40 @@ const inputMixin = (superclass) =>
 		}
 
 		connectedCallback() {
-			this.baseEle = this.shadowRoot.querySelector(this.baseSelector);
 			super.connectedCallback?.();
 
+			this.baseEle = this.shadowRoot.querySelector(this.baseSelector);
+
 			// this is needed in order to make sure the form input validation is working
 			if (!this.hasAttribute('tabindex')) {
 				this.setAttribute('tabindex', 0);
 			}
 
-			const input =
-				this.baseEle.querySelector('input') ||
-				this.baseEle.querySelector('textarea');
-			if (!input) throw Error('no input was found');
+			this.inputElement ??= this.baseEle.shadowRoot.querySelector('slot[name="input"]')?.assignedElements()[0] ||
+				this.baseEle.shadowRoot.querySelector('slot[name="textarea"]')?.assignedElements()[0];
+			if (!this.inputElement) throw Error('no input was found');
 
 			// sync properties
-			propertyObserver(this, input, 'value');
-			this.setSelectionRange = input.setSelectionRange.bind(input);
+			propertyObserver(this, this.inputElement, 'value');
+			this.setSelectionRange = this.inputElement.setSelectionRange?.bind(this.inputElement);
 
-			this.validity = input.validity;
+			this.validity = this.inputElement.validity;
 
 			this.setValidity = () => {
-				this.#internals.setValidity(input.validity, input.validationMessage);
+				this.#internals.setValidity(this.inputElement.validity, this.inputElement.validationMessage);
 			};
 
-			input.oninput = () => {
-				this.value = input.value;
+			this.inputElement.oninput = () => {
+				this.value = this.inputElement.value;
 				this.setValidity();
 			};
 
 			this.onfocus = () => {
-				setTimeout(() => input.reportValidity(), 0);
+				setTimeout(() => this.inputElement.reportValidity(), 0);
 				this.validate();
 			};
 
-			input.oninvalid = () => {
+			this.inputElement.oninvalid = () => {
 				this.validate();
 			};
 		}
@@ -464,7 +516,7 @@ const compose =
 	(val) =>
 		fns.reduceRight((res, fn) => fn(res), val);
 
-const componentName$c = getComponentName('button');
+const componentName$f = getComponentName('button');
 
 const editorOverrides = `vaadin-button::part(label) { pointer-events: none; }`;
 const resetStyles = `
@@ -487,17 +539,16 @@ const iconStyles = `
 	}
 `;
 
-const selectors$2 = {
+const selectors$3 = {
 	label: '::part(label)'
 };
 
 const Button = compose(
 	createStyleMixin({
-		// todo: do we want to change the mapping structure to this? ['aa', 'aaa', {'color': [{ selector: '::part(label)' }]}],
 		mappings: {
 			backgroundColor: {},
 			borderRadius: {},
-			color: { selector: selectors$2.label },
+			color: { selector: selectors$3.label },
 			borderColor: {},
 			borderStyle: {},
 			borderWidth: {},
@@ -505,8 +556,8 @@ const Button = compose(
 			height: {},
 			width: matchHostStyle(),
 			cursor: {},
-			padding: [{ selector: selectors$2.label }],
-			textDecoration: { selector: selectors$2.label }
+			padding: [{ selector: selectors$3.label }],
+			textDecoration: { selector: selectors$3.label }
 		}
 	}),
 	draggableMixin,
@@ -518,7 +569,7 @@ const Button = compose(
 		style: () =>
 			`${resetStyles} ${editorOverrides} ${iconStyles} ${loadingIndicatorStyles}`,
 		excludeAttrsSync: ['tabindex'],
-		componentName: componentName$c
+		componentName: componentName$f
 	})
 );
 
@@ -551,9 +602,9 @@ const loadingIndicatorStyles = `
 	}
 `;
 
-customElements.define(componentName$c, Button);
+customElements.define(componentName$f, Button);
 
-const selectors$1 = {
+const selectors$2 = {
 	label: '::part(label)',
 	input: '::part(input-field)',
 	readOnlyInput: '[readonly]::part(input-field)::after',
@@ -561,36 +612,36 @@ const selectors$1 = {
 };
 
 var textFieldMappings = {
-	color: { selector: selectors$1.input },
-	backgroundColor: { selector: selectors$1.input },
-	color: { selector: selectors$1.input },
+	color: { selector: selectors$2.input },
+	backgroundColor: { selector: selectors$2.input },
+	color: { selector: selectors$2.input },
 	width: matchHostStyle({}),
 	borderColor: [
-		{ selector: selectors$1.input },
-		{ selector: selectors$1.readOnlyInput }
+		{ selector: selectors$2.input },
+		{ selector: selectors$2.readOnlyInput }
 	],
 	borderWidth: [
-		{ selector: selectors$1.input },
-		{ selector: selectors$1.readOnlyInput }
+		{ selector: selectors$2.input },
+		{ selector: selectors$2.readOnlyInput }
 	],
 	borderStyle: [
-		{ selector: selectors$1.input },
-		{ selector: selectors$1.readOnlyInput }
+		{ selector: selectors$2.input },
+		{ selector: selectors$2.readOnlyInput }
 	],
-	borderRadius: { selector: selectors$1.input },
-	boxShadow: { selector: selectors$1.input },
+	borderRadius: { selector: selectors$2.input },
+	boxShadow: { selector: selectors$2.input },
 	fontSize: {},
-	height: { selector: selectors$1.input },
-	padding: { selector: selectors$1.input },
-	outline: { selector: selectors$1.input },
-	outlineOffset: { selector: selectors$1.input },
+	height: { selector: selectors$2.input },
+	padding: { selector: selectors$2.input },
+	outline: { selector: selectors$2.input },
+	outlineOffset: { selector: selectors$2.input },
 
-	placeholderColor: { selector: selectors$1.placeholder, property: 'color' }
+	placeholderColor: { selector: selectors$2.placeholder, property: 'color' }
 };
 
-const componentName$b = getComponentName('text-field');
+const componentName$e = getComponentName('text-field');
 
-let overrides$5 = ``;
+let overrides$6 = ``;
 
 const TextField = compose(
 	createStyleMixin({
@@ -603,13 +654,13 @@ const TextField = compose(
 	createProxy({
 		slots: ['prefix', 'suffix'],
 		wrappedEleName: 'vaadin-text-field',
-		style: () => overrides$5,
+		style: () => overrides$6,
 		excludeAttrsSync: ['tabindex'],
-		componentName: componentName$b
+		componentName: componentName$e
 	})
 );
 
-overrides$5 = `
+overrides$6 = `
 	:host {
 		display: inline-block;
 	}
@@ -650,18 +701,18 @@ overrides$5 = `
 	}
 `;
 
-customElements.define(componentName$b, TextField);
+customElements.define(componentName$e, TextField);
 
 const template = document.createElement('template');
 
-const componentName$a = getComponentName('combo');
+const componentName$d = getComponentName('combo');
 
 template.innerHTML = `
   <descope-button></descope-button>
   <descope-text-field></descope-text-field>
 `;
 
-class Combo extends HTMLElement {
+class Combo extends DescopeBaseClass {
 	constructor() {
 		super();
 
@@ -671,11 +722,11 @@ class Combo extends HTMLElement {
 	}
 }
 
-customElements.define(componentName$a, Combo);
+customElements.define(componentName$d, Combo);
 
-const componentName$9 = getComponentName('number-field');
+const componentName$c = getComponentName('number-field');
 
-let overrides$4 = ``;
+let overrides$5 = ``;
 
 const NumberField = compose(
 	createStyleMixin({
@@ -690,13 +741,13 @@ const NumberField = compose(
 	createProxy({
 		slots: ['prefix', 'suffix'],
 		wrappedEleName: 'vaadin-number-field',
-		style: () => overrides$4,
+		style: () => overrides$5,
 		excludeAttrsSync: ['tabindex'],
-		componentName: componentName$9
+		componentName: componentName$c
 	})
 );
 
-overrides$4 = `
+overrides$5 = `
 	:host {
 		display: inline-block;
 	}
@@ -736,11 +787,11 @@ overrides$4 = `
 	}
 `;
 
-customElements.define(componentName$9, NumberField);
+customElements.define(componentName$c, NumberField);
 
-const componentName$8 = getComponentName('email-field');
+const componentName$b = getComponentName('email-field');
 
-let overrides$3 = ``;
+let overrides$4 = ``;
 
 const EmailField = compose(
 	createStyleMixin({
@@ -755,13 +806,13 @@ const EmailField = compose(
 	createProxy({
 		slots: ['suffix'],
 		wrappedEleName: 'vaadin-email-field',
-		style: () => overrides$3,
+		style: () => overrides$4,
 		excludeAttrsSync: ['tabindex'],
-		componentName: componentName$8
+		componentName: componentName$b
 	})
 );
 
-overrides$3 = `
+overrides$4 = `
 	:host {
 		display: inline-block;
 	}
@@ -801,17 +852,16 @@ overrides$3 = `
 	}
 `;
 
-customElements.define(componentName$8, EmailField);
+customElements.define(componentName$b, EmailField);
 
-const componentName$7 = getComponentName('password-field');
+const componentName$a = getComponentName('password-field');
 
-let overrides$2 = ``;
+let overrides$3 = ``;
 
 const PasswordField = compose(
 	createStyleMixin({
 		mappings: {
 			...textFieldMappings,
-			// todo: override cursor from lumo
 			revealCursor: [
 				{
 					selector: '::part(reveal-button)::before',
@@ -827,13 +877,13 @@ const PasswordField = compose(
 	createProxy({
 		slots: ['suffix'],
 		wrappedEleName: 'vaadin-password-field',
-		style: () => overrides$2,
+		style: () => overrides$3,
 		excludeAttrsSync: ['tabindex'],
-		componentName: componentName$7
+		componentName: componentName$a
 	})
 );
 
-overrides$2 = `
+overrides$3 = `
 	:host {
 		display: inline-block;
 	}
@@ -873,32 +923,32 @@ overrides$2 = `
 	}
 `;
 
-customElements.define(componentName$7, PasswordField);
+customElements.define(componentName$a, PasswordField);
 
-const componentName$6 = getComponentName('text-area');
+const componentName$9 = getComponentName('text-area');
 
-const selectors = {
+const selectors$1 = {
 	label: '::part(label)',
 	input: '::part(input-field)',
 	required: '::part(required-indicator)::after'
 };
 
-let overrides$1 = ``;
+let overrides$2 = ``;
 
 const TextArea = compose(
 	createStyleMixin({
 		mappings: {
 			resize: { selector: '> textarea' },
-			color: { selector: selectors.label },
+			color: { selector: selectors$1.label },
 			cursor: {},
 			width: matchHostStyle(),
-			backgroundColor: { selector: selectors.input },
-			borderWidth: { selector: selectors.input },
-			borderStyle: { selector: selectors.input },
-			borderColor: { selector: selectors.input },
-			borderRadius: { selector: selectors.input },
-			outline: { selector: selectors.input },
-			outlineOffset: { selector: selectors.input }
+			backgroundColor: { selector: selectors$1.input },
+			borderWidth: { selector: selectors$1.input },
+			borderStyle: { selector: selectors$1.input },
+			borderColor: { selector: selectors$1.input },
+			borderRadius: { selector: selectors$1.input },
+			outline: { selector: selectors$1.input },
+			outlineOffset: { selector: selectors$1.input }
 		}
 	}),
 	draggableMixin,
@@ -908,13 +958,13 @@ const TextArea = compose(
 	createProxy({
 		slots: [],
 		wrappedEleName: 'vaadin-text-area',
-		style: () => overrides$1,
+		style: () => overrides$2,
 		excludeAttrsSync: ['tabindex'],
-		componentName: componentName$6
+		componentName: componentName$9
 	})
 );
 
-overrides$1 = `
+overrides$2 = `
 	:host {
 		display: inline-block;
 	}
@@ -935,34 +985,41 @@ overrides$1 = `
 	}	
 `;
 
-customElements.define(componentName$6, TextArea);
+customElements.define(componentName$9, TextArea);
 
-const componentName$5 = getComponentName('date-picker');
+const componentName$8 = getComponentName('date-picker');
 
 const DatePicker = compose(
 	draggableMixin,
 	componentNameValidationMixin
 )(
 	createProxy({
-		componentName: componentName$5,
+		componentName: componentName$8,
 		slots: ['prefix', 'suffix'],
 		wrappedEleName: 'vaadin-date-picker',
 		style: ``
 	})
 );
 
-customElements.define(componentName$5, DatePicker);
+customElements.define(componentName$8, DatePicker);
 
-const componentName$4 = getComponentName('container');
+const componentName$7 = getComponentName('container');
 
-class RawContainer extends HTMLElement {
+class RawContainer extends DescopeBaseClass {
 	static get componentName() {
-		return componentName$4;
+		return componentName$7;
 	}
 	constructor() {
 		super();
 		const template = document.createElement('template');
-		template.innerHTML = `<slot></slot>`;
+		template.innerHTML = `
+			<style>
+				:host > slot {
+					box-sizing: border-box;
+				}
+			</style>
+			<slot></slot>
+		`;
 
 		this.attachShadow({ mode: 'open' });
 		this.shadowRoot.appendChild(template.content.cloneNode(true));
@@ -973,10 +1030,9 @@ class RawContainer extends HTMLElement {
 
 const Container = compose(
 	createStyleMixin({
-		// todo: do we want to change the mapping structure to this? ['aa', 'aaa', {'color': [{ selector: '::part(label)' }]}],
 		mappings: {
-			height: {},
-			width: {},
+			height: matchHostStyle(),
+			width: matchHostStyle(),
 
 			verticalPadding: [
 				{ property: 'padding-top' },
@@ -987,7 +1043,7 @@ const Container = compose(
 				{ property: 'padding-right' }
 			],
 
-			display: {},
+			display: {}, // maybe this should be hardcoded to flex
 			flexDirection: {},
 			justifyContent: {},
 			alignItems: {},
@@ -1007,13 +1063,13 @@ const Container = compose(
 	componentNameValidationMixin
 )(RawContainer);
 
-customElements.define(componentName$4, Container);
+customElements.define(componentName$7, Container);
 
-const componentName$3 = getComponentName('text');
+const componentName$6 = getComponentName('text');
 
-class RawText extends HTMLElement {
+class RawText extends DescopeBaseClass {
 	static get componentName() {
-		return componentName$3;
+		return componentName$6;
 	}
 	constructor() {
 		super();
@@ -1037,6 +1093,12 @@ const Text = compose(
 			fontWeight: {},
 			width: {},
 			color: {},
+			letterSpacing: {},
+			textShadow: {},
+			borderWidth: {},
+			borderStyle: {},
+			borderColor: {},
+			textTransform: {},
 			textAlign: matchHostStyle(),
 			display: matchHostStyle()
 		}
@@ -1045,7 +1107,254 @@ const Text = compose(
 	componentNameValidationMixin
 )(RawText);
 
-customElements.define(componentName$3, Text);
+customElements.define(componentName$6, Text);
+
+const getChildObserver = (callback) => {
+	return new MutationObserver((mutationsList) => {
+		for (const mutation of mutationsList) {
+			if (mutation.type === 'childList') {
+				callback(mutation);
+			}
+		}
+	});
+};
+
+const insertNestingLevel = (srcEle, nestingEle) => {
+	nestingEle.append(...srcEle.childNodes);
+	srcEle.appendChild(nestingEle);
+};
+
+// adds a nesting element to the component, and move all existing children
+// to be under the nesting element
+const enforceNestingElementsStylesMixin =
+	({ nestingElementTagName, nestingElementDestSlotName, forwardAttrOptions }) =>
+	(superclass) => {
+		const getChildNodeEle = () =>
+			Object.assign(document.createElement(nestingElementTagName), {
+				slot: nestingElementDestSlotName
+			});
+
+		let childObserver;
+		
+		const getObserver = () => childObserver;
+
+		return class EnforceNestingElementsStylesMixinClass extends superclass {
+			constructor() {
+				super();
+
+				const childObserverCallback = () => {
+					// we are going to change the DOM, so we need to disconnect the observer before
+					// and reconnect it after the child component is added
+					getObserver().disconnect(this.shadowRoot.host);
+
+					const isNestingElementExist = this.shadowRoot.host.querySelector(nestingElementTagName);
+					const hasNewChildren = this.shadowRoot.host.childNodes.length > 0;
+
+					if (!isNestingElementExist && hasNewChildren) {
+						// if before there were no children and now there are children - insert
+						insertNestingLevel(this.shadowRoot.host, getChildNodeEle());
+					} else if (isNestingElementExist && hasNewChildren) {
+						// if children existed, and they changed -
+						// we need to update (move) the new children into
+						// descope-text and remove previous children
+						this.shadowRoot.host.querySelector(child).remove();
+						insertNestingLevel(this.shadowRoot.host, getChildNodeEle());
+					}
+					else if (isNestingElementExist && !hasNewChildren) {
+						// if children existed and now there are none -
+						// we need to remove descope-text completely
+						this.shadowRoot.host.querySelector(child).remove();
+					}
+
+					// we need a new observer, because we remove the nesting element
+					this.shadowRoot.host.querySelector(nestingElementTagName) &&
+						forwardAttrs(
+							this.shadowRoot.host,
+							this.shadowRoot.host.querySelector(nestingElementTagName),
+							forwardAttrOptions
+						);
+
+						getObserver().observe(this.shadowRoot.host, {
+						childList: true
+					});
+				};
+
+				childObserver = getChildObserver(childObserverCallback);
+			}
+
+			connectedCallback() {
+				super.connectedCallback?.();
+
+				if (this.shadowRoot.host.childNodes.length > 0) {
+					// on the first render - we want to move all component's children to be under descope-text
+					insertNestingLevel(this.shadowRoot.host, getChildNodeEle());
+
+					forwardAttrs(
+						this.shadowRoot.host,
+						this.shadowRoot.host.querySelector(nestingElementTagName),
+						forwardAttrOptions
+					);
+				}
+
+				getObserver().observe(this.shadowRoot.host, {
+					childList: true
+				});
+			}
+		};
+	};
+
+const componentName$5 = getComponentName('divider');
+class RawDivider extends DescopeBaseClass {
+	static get componentName() {
+		return componentName$5;
+	}
+	constructor() {
+		super();
+		const template = document.createElement('template');
+		template.innerHTML = `
+			<style>
+				:host > div {
+					display: flex;
+					height: 100%;
+				}
+				:host > div::before,
+				:host > div::after {
+					content: '';
+					flex-grow: 1;
+					width: 100%;
+				}
+				::slotted(*) {
+					flex-grow: 0;
+					flex-shrink: 0;
+				}
+			</style>
+			<div>
+				<slot></slot>
+				<slot name="text"></slot>
+			</div>
+		`;
+		this.attachShadow({ mode: 'open' });
+		this.shadowRoot.appendChild(template.content.cloneNode(true));
+
+		this.baseSelector = ':host > div';
+	}
+}
+
+const selectors = {
+	root: { selector: '' },
+	before: { selector: '::before' },
+	after: { selector: '::after' },
+	slotted: { selector: () => '::slotted(*)' }
+};
+
+const { root, before, after, slotted } = selectors;
+
+const Divider = compose(
+	enforceNestingElementsStylesMixin({
+		nestingElementTagName: 'descope-text',
+		nestingElementDestSlotName: 'text',
+		forwardAttrOptions: {
+			includeAttrs: ['mode', 'variant'],
+			excludeAttrs: []
+		}
+	}),
+	createStyleMixin({
+		mappings: {
+			minHeight: root,
+			alignItems: root,
+			alignSelf: root,
+			flexDirection: root,
+			padding: slotted,
+			width: matchHostStyle(),
+			height: [before, after],
+			backgroundColor: [before, after],
+			opacity: [before, after],
+			textWidth: { ...slotted, property: 'width' }
+		}
+	}),
+	draggableMixin,
+	componentNameValidationMixin
+)(RawDivider);
+
+customElements.define(componentName$5, Divider);
+
+const componentName$4 = getComponentName('logo');
+
+let style;
+const getStyle = () => style;
+
+class RawLogo extends DescopeBaseClass {
+	static get componentName() {
+		return componentName$4;
+	}
+	constructor() {
+		super();
+		const template = document.createElement('template');
+		template.innerHTML = `
+		<style>
+			${getStyle()}
+		</style>
+		<div></div>`;
+
+		this.attachShadow({ mode: 'open' });
+		this.shadowRoot.appendChild(template.content.cloneNode(true));
+
+		this.baseSelector = ':host > div';
+	}
+}
+
+const Logo = compose(
+	createStyleMixin({
+		mappings: {
+			height: {},
+			width: {},
+			url: {},
+			fallbackUrl: {}
+		}
+	}),
+	draggableMixin,
+	componentNameValidationMixin
+)(RawLogo);
+
+style = `
+:host {
+	display: inline-block;
+}
+:host > div {
+	display: inline-block;
+	content: var(${Logo.cssVarList.url}, var(${Logo.cssVarList.fallbackUrl}));
+}
+`;
+
+customElements.define(componentName$4, Logo);
+
+const componentName$3 = getComponentName('checkbox');
+
+const Checkbox = compose(
+	createStyleMixin({
+		mappings: {
+			width: matchHostStyle(),
+			cursor: [{}, { selector: '> label' }]
+		}
+	}),
+	draggableMixin,
+	inputMixin,
+	componentNameValidationMixin
+)(
+	createProxy({
+		slots: [],
+		wrappedEleName: 'vaadin-checkbox',
+		style: `
+		:host {
+			display: inline-block;
+		}
+		`,
+		excludeAttrsSync: ['tabindex'],
+		componentName: componentName$3
+	})
+);
+
+customElements.define(componentName$3, Checkbox);
 
 const getVarName = (path) => getCssVarName(DESCOPE_PREFIX, ...path);
 
@@ -1286,7 +1595,7 @@ var globals = {
 };
 
 const globalRefs$4 = getThemeRefs(globals);
-const vars$8 = Button.cssVarList;
+const vars$9 = Button.cssVarList;
 
 const mode = {
 	primary: globalRefs$4.colors.primary,
@@ -1296,83 +1605,83 @@ const mode = {
 	surface: globalRefs$4.colors.surface
 };
 
-const [helperTheme$1, helperRefs$1] = createHelperVars({ mode }, componentName$c);
+const [helperTheme$1, helperRefs$1] = createHelperVars({ mode }, componentName$f);
 
 const button = {
 	...helperTheme$1,
 
 	size: {
 		xs: {
-			[vars$8.height]: '10px',
-			[vars$8.fontSize]: '10px',
-			[vars$8.padding]: `0 ${globalRefs$4.spacing.xs}`
+			[vars$9.height]: '10px',
+			[vars$9.fontSize]: '10px',
+			[vars$9.padding]: `0 ${globalRefs$4.spacing.xs}`
 		},
 		sm: {
-			[vars$8.height]: '20px',
-			[vars$8.fontSize]: '10px',
-			[vars$8.padding]: `0 ${globalRefs$4.spacing.sm}`
+			[vars$9.height]: '20px',
+			[vars$9.fontSize]: '10px',
+			[vars$9.padding]: `0 ${globalRefs$4.spacing.sm}`
 		},
 		md: {
-			[vars$8.height]: '30px',
-			[vars$8.fontSize]: '14px',
-			[vars$8.padding]: `0 ${globalRefs$4.spacing.md}`
+			[vars$9.height]: '30px',
+			[vars$9.fontSize]: '14px',
+			[vars$9.padding]: `0 ${globalRefs$4.spacing.md}`
 		},
 		lg: {
-			[vars$8.height]: '40px',
-			[vars$8.fontSize]: '20px',
-			[vars$8.padding]: `0 ${globalRefs$4.spacing.lg}`
+			[vars$9.height]: '40px',
+			[vars$9.fontSize]: '20px',
+			[vars$9.padding]: `0 ${globalRefs$4.spacing.lg}`
 		},
 		xl: {
-			[vars$8.height]: '50px',
-			[vars$8.fontSize]: '25px',
-			[vars$8.padding]: `0 ${globalRefs$4.spacing.xl}`
+			[vars$9.height]: '50px',
+			[vars$9.fontSize]: '25px',
+			[vars$9.padding]: `0 ${globalRefs$4.spacing.xl}`
 		}
 	},
 
-	[vars$8.borderRadius]: globalRefs$4.radius.lg,
-	[vars$8.cursor]: 'pointer',
-	[vars$8.borderWidth]: '2px',
-	[vars$8.borderStyle]: 'solid',
-	[vars$8.borderColor]: 'transparent',
+	[vars$9.borderRadius]: globalRefs$4.radius.lg,
+	[vars$9.cursor]: 'pointer',
+	[vars$9.borderWidth]: '2px',
+	[vars$9.borderStyle]: 'solid',
+	[vars$9.borderColor]: 'transparent',
 
 	_fullWidth: {
-		[vars$8.width]: '100%'
+		[vars$9.width]: '100%'
 	},
 	_loading: {
-		[vars$8.cursor]: 'wait'
+		[vars$9.cursor]: 'wait'
 	},
 
 	variant: {
 		contained: {
-			[vars$8.color]: helperRefs$1.contrast,
-			[vars$8.backgroundColor]: helperRefs$1.main,
+			[vars$9.color]: helperRefs$1.contrast,
+			[vars$9.backgroundColor]: helperRefs$1.main,
 			_hover: {
-				[vars$8.backgroundColor]: helperRefs$1.dark
+				[vars$9.backgroundColor]: helperRefs$1.dark
 			},
 			_loading: {
-				[vars$8.backgroundColor]: helperRefs$1.main
+				[vars$9.backgroundColor]: helperRefs$1.main
 			}
 		},
 		outline: {
-			[vars$8.color]: helperRefs$1.main,
-			[vars$8.borderColor]: helperRefs$1.main,
+			[vars$9.color]: helperRefs$1.main,
+			[vars$9.borderColor]: helperRefs$1.main,
 			_hover: {
-				[vars$8.color]: helperRefs$1.dark,
-				[vars$8.borderColor]: helperRefs$1.dark,
+				[vars$9.color]: helperRefs$1.dark,
+				[vars$9.borderColor]: helperRefs$1.dark,
 				_error: {
-					[vars$8.color]: helperRefs$1.error
+					[vars$9.color]: helperRefs$1.error
 				}
 			}
 		},
 		link: {
-			[vars$8.color]: helperRefs$1.main,
-			[vars$8.padding]: 0,
-			[vars$8.margin]: 0,
-			[vars$8.lineHeight]: helperRefs$1.height,
-			[vars$8.borderRadius]: 0,
+			[vars$9.color]: helperRefs$1.main,
+			[vars$9.padding]: 0,
+			[vars$9.margin]: 0,
+			[vars$9.lineHeight]: helperRefs$1.height,
+			[vars$9.borderRadius]: 0,
 			_hover: {
-				[vars$8.color]: helperRefs$1.main,
-				[vars$8.textDecoration]: 'underline'
+				[vars$9.color]: helperRefs$1.main,
+				[vars$9.textDecoration]: 'underline'
 			}
 		}
 	}
@@ -1380,7 +1689,7 @@ const button = {
 
 const globalRefs$3 = getThemeRefs(globals);
 
-const vars$7 = TextField.cssVarList;
+const vars$8 = TextField.cssVarList;
 
 const textField = (vars) => ({
 	size: {
@@ -1450,13 +1759,13 @@ const textField = (vars) => ({
 	}
 });
 
-var textField$1 = textField(vars$7);
+var textField$1 = textField(vars$8);
 
-const vars$6 = PasswordField.cssVarList;
+const vars$7 = PasswordField.cssVarList;
 
 const passwordField = {
-	...textField(vars$6),
-	[vars$6.revealCursor]: 'pointer'
+	...textField(vars$7),
+	[vars$7.revealCursor]: 'pointer'
 };
 
 const numberField = {
@@ -1468,78 +1777,52 @@ const emailField = {
 };
 
 const globalRefs$2 = getThemeRefs(globals);
-const vars$5 = TextArea.cssVarList;
+const vars$6 = TextArea.cssVarList;
 
 const textArea = {
-	[vars$5.color]: globalRefs$2.colors.primary.main,
-	[vars$5.backgroundColor]: globalRefs$2.colors.surface.light,
-	[vars$5.resize]: 'vertical',
+	[vars$6.color]: globalRefs$2.colors.primary.main,
+	[vars$6.backgroundColor]: globalRefs$2.colors.surface.light,
+	[vars$6.resize]: 'vertical',
 
-	[vars$5.borderRadius]: globalRefs$2.radius.sm,
-	[vars$5.borderWidth]: '1px',
-	[vars$5.borderStyle]: 'solid',
-	[vars$5.borderColor]: 'transparent',
+	[vars$6.borderRadius]: globalRefs$2.radius.sm,
+	[vars$6.borderWidth]: '1px',
+	[vars$6.borderStyle]: 'solid',
+	[vars$6.borderColor]: 'transparent',
 
 	_borderOffset: {
-		[vars$5.outlineOffset]: '2px'
+		[vars$6.outlineOffset]: '2px'
 	},
 
 	_bordered: {
-		[vars$5.borderColor]: globalRefs$2.colors.surface.main
+		[vars$6.borderColor]: globalRefs$2.colors.surface.main
 	},
 
 	_focused: {
-		[vars$5.outline]: `2px solid ${globalRefs$2.colors.surface.main}`
+		[vars$6.outline]: `2px solid ${globalRefs$2.colors.surface.main}`
 	},
 
 	_fullWidth: {
-		[vars$5.width]: '100%'
+		[vars$6.width]: '100%'
 	},
 
 	_disabled: {
-		[vars$5.cursor]: 'not-allowed'
+		[vars$6.cursor]: 'not-allowed'
 	},
 
 	_invalid: {
-		[vars$5.outline]: `2px solid ${globalRefs$2.colors.error.main}`
+		[vars$6.outline]: `2px solid ${globalRefs$2.colors.error.main}`
 	}
 };
 
-const componentName$2 = getComponentName('checkbox');
-
-const Checkbox = compose(
-	createStyleMixin({
-		mappings: {
-			width: matchHostStyle(),
-			cursor: [{}, { selector: '> label' }]
-		}
-	}),
-	draggableMixin,
-	inputMixin,
-	componentNameValidationMixin
-)(
-	createProxy({
-		slots: [],
-		wrappedEleName: 'vaadin-checkbox',
-		style: `
-		:host {
-			display: inline-block;
-		}
-		`,
-		excludeAttrsSync: ['tabindex'],
-		componentName: componentName$2
-	})
-);
-
-const vars$4 = Checkbox.cssVarList;
+const vars$5 = Checkbox.cssVarList;
 
 const checkbox = {
-	[vars$4.cursor]: 'pointer'
+	[vars$5.cursor]: 'pointer'
 };
 
-const componentName$1 = getComponentName('switch-toggle');
+const componentName$2 = getComponentName('switch-toggle');
 
-let overrides = ``;
+let overrides$1 = ``;
 
 const SwitchToggle = compose(
 	createStyleMixin({
@@ -1555,13 +1838,13 @@ const SwitchToggle = compose(
 	createProxy({
 		slots: [],
 		wrappedEleName: 'vaadin-checkbox',
-		style: () => overrides,
+		style: () => overrides$1,
 		excludeAttrsSync: ['tabindex'],
-		componentName: componentName$1
+		componentName: componentName$2
 	})
 );
 
-overrides = `
+overrides$1 = `
 	:host {
 		display: inline-block;
 	}
@@ -1611,16 +1894,16 @@ overrides = `
 	}
 `;
 
-const vars$3 = SwitchToggle.cssVarList;
+const vars$4 = SwitchToggle.cssVarList;
 
 const swtichToggle = {
-	[vars$3.width]: '70px',
-	[vars$3.cursor]: [{}, { selector: '> label' }]
+	[vars$4.width]: '70px',
+	[vars$4.cursor]: [{}, { selector: '> label' }]
 };
 
 const globalRefs$1 = getThemeRefs(globals);
 
-const vars$2 = Container.cssVarList;
+const vars$3 = Container.cssVarList;
 
 const verticalAlignment = {
 	start: { verticalAlignment: 'start' },
@@ -1643,31 +1926,31 @@ const [helperTheme, helperRefs, helperVars] =
 
 const container = {
 	...helperTheme,
-	[vars$2.display]: 'flex',
+	[vars$3.display]: 'flex',
 	verticalPadding: {
-		sm: { [vars$2.verticalPadding]: '5px' },
-		md: { [vars$2.verticalPadding]: '10px' },
-		lg: { [vars$2.verticalPadding]: '20px' },
+		sm: { [vars$3.verticalPadding]: '5px' },
+		md: { [vars$3.verticalPadding]: '10px' },
+		lg: { [vars$3.verticalPadding]: '20px' },
 	},
 	horizontalPadding: {
-		sm: { [vars$2.horizontalPadding]: '5px' },
-		md: { [vars$2.horizontalPadding]: '10px' },
-		lg: { [vars$2.horizontalPadding]: '20px' },
+		sm: { [vars$3.horizontalPadding]: '5px' },
+		md: { [vars$3.horizontalPadding]: '10px' },
+		lg: { [vars$3.horizontalPadding]: '20px' },
 	},
 	direction: {
 		row: {
-			[vars$2.flexDirection]: 'row',
-			[vars$2.alignItems]: helperRefs.verticalAlignment,
-			[vars$2.justifyContent]: helperRefs.horizontalAlignment,
+			[vars$3.flexDirection]: 'row',
+			[vars$3.alignItems]: helperRefs.verticalAlignment,
+			[vars$3.justifyContent]: helperRefs.horizontalAlignment,
 			horizontalAlignment: {
 				spaceBetween: { [helperVars.horizontalAlignment]: 'space-between' },
 			}
 		},
 
 		column: {
-			[vars$2.flexDirection]: 'column',
-			[vars$2.alignItems]: helperRefs.horizontalAlignment,
-			[vars$2.justifyContent]: helperRefs.verticalAlignment,
+			[vars$3.flexDirection]: 'column',
+			[vars$3.alignItems]: helperRefs.horizontalAlignment,
+			[vars$3.justifyContent]: helperRefs.verticalAlignment,
 			verticalAlignment: {
 				spaceBetween: { [helperVars.verticalAlignment]: 'space-between' }
 			}
@@ -1676,174 +1959,286 @@ const container = {
 
 	spaceBetween: {
 		sm: {
-			[vars$2.gap]: '10px'
+			[vars$3.gap]: '10px'
 		},
 		md: {
-			[vars$2.gap]: '20px'
+			[vars$3.gap]: '20px'
 		},
 		lg: {
-			[vars$2.gap]: '30px'
+			[vars$3.gap]: '30px'
 		}
 	},
 
 	shadow: {
 		sm: {
-			[vars$2.boxShadow]: `${globalRefs$1.shadow.wide.sm} ${helperRefs.shadowColor}, ${globalRefs$1.shadow.narrow.sm} ${helperRefs.shadowColor}`
+			[vars$3.boxShadow]: `${globalRefs$1.shadow.wide.sm} ${helperRefs.shadowColor}, ${globalRefs$1.shadow.narrow.sm} ${helperRefs.shadowColor}`
 		},
 		md: {
-			[vars$2.boxShadow]: `${globalRefs$1.shadow.wide.md} ${helperRefs.shadowColor}, ${globalRefs$1.shadow.narrow.md} ${helperRefs.shadowColor}`
+			[vars$3.boxShadow]: `${globalRefs$1.shadow.wide.md} ${helperRefs.shadowColor}, ${globalRefs$1.shadow.narrow.md} ${helperRefs.shadowColor}`
 		},
 		lg: {
-			[vars$2.boxShadow]: `${globalRefs$1.shadow.wide.lg} ${helperRefs.shadowColor}, ${globalRefs$1.shadow.narrow.lg} ${helperRefs.shadowColor}`
+			[vars$3.boxShadow]: `${globalRefs$1.shadow.wide.lg} ${helperRefs.shadowColor}, ${globalRefs$1.shadow.narrow.lg} ${helperRefs.shadowColor}`
 		},
 		xl: {
-			[vars$2.boxShadow]: `${globalRefs$1.shadow.wide.xl} ${helperRefs.shadowColor}, ${globalRefs$1.shadow.narrow.xl} ${helperRefs.shadowColor}`
+			[vars$3.boxShadow]: `${globalRefs$1.shadow.wide.xl} ${helperRefs.shadowColor}, ${globalRefs$1.shadow.narrow.xl} ${helperRefs.shadowColor}`
 		},
 		'2xl': {
 			[helperVars.shadowColor]: '#00000050',
-			[vars$2.boxShadow]: `${globalRefs$1.shadow.wide['2xl']} ${helperRefs.shadowColor}`
+			[vars$3.boxShadow]: `${globalRefs$1.shadow.wide['2xl']} ${helperRefs.shadowColor}`
 		},
 	},
 
 	borderRadius: {
 		sm: {
-			[vars$2.borderRadius]: globalRefs$1.radius.sm
+			[vars$3.borderRadius]: globalRefs$1.radius.sm
 		},
 		md: {
-			[vars$2.borderRadius]: globalRefs$1.radius.md
+			[vars$3.borderRadius]: globalRefs$1.radius.md
 		},
 		lg: {
-			[vars$2.borderRadius]: globalRefs$1.radius.lg
+			[vars$3.borderRadius]: globalRefs$1.radius.lg
 		},
 	}
 };
 
-const componentName = getComponentName('logo');
-
-let style;
-const getStyle = () => style;
-
-class RawLogo extends HTMLElement {
-	static get componentName() {
-		return componentName;
-	}
-	constructor() {
-		super();
-		const template = document.createElement('template');
-		template.innerHTML = `
-		<style>
-			${getStyle()}
-		</style>
-		<div></div>`;
-
-		this.attachShadow({ mode: 'open' });
-		this.shadowRoot.appendChild(template.content.cloneNode(true));
-
-		this.baseSelector = ':host > div';
-	}
-}
-
-const Logo = compose(
-	createStyleMixin({
-		mappings: {
-			height: {},
-			width: {},
-			url: {},
-			fallbackUrl: {},
-		}
-	}),
-	draggableMixin,
-	componentNameValidationMixin
-)(RawLogo);
-
-style = `
-:host {
-	display: inline-block;
-}
-:host > div {
-	display: inline-block;
-	content: var(${Logo.cssVarList.url}, var(${Logo.cssVarList.fallbackUrl}));
-}
-`;
-
-const vars$1 = Logo.cssVarList;
+const vars$2 = Logo.cssVarList;
 
 const logo = {
-	[vars$1.fallbackUrl]: 'url(https://content.app.descope.com/assets/flows/noLogoPlaceholder.svg)'
+	[vars$2.fallbackUrl]: 'url(https://content.app.descope.com/assets/flows/noLogoPlaceholder.svg)'
 };
 
 const globalRefs = getThemeRefs(globals);
 
-const vars = Text.cssVarList;
+const vars$1 = Text.cssVarList;
 
 const text = {
-	[vars.lineHeight]: '1em',
-	[vars.display]: 'inline-block',
-	[vars.textAlign]: 'left',
-	[vars.color]: globalRefs.colors.surface.dark,
+	[vars$1.lineHeight]: '1em',
+	[vars$1.display]: 'inline-block',
+	[vars$1.textAlign]: 'left',
+	[vars$1.color]: globalRefs.colors.surface.dark,
 	variant: {
 		h1: {
-			[vars.fontSize]: globalRefs.typography.h1.size,
-			[vars.fontWeight]: globalRefs.typography.h1.weight,
-			[vars.fontFamily]: globalRefs.typography.h1.font
+			[vars$1.fontSize]: globalRefs.typography.h1.size,
+			[vars$1.fontWeight]: globalRefs.typography.h1.weight,
+			[vars$1.fontFamily]: globalRefs.typography.h1.font
 		},
 		h2: {
-			[vars.fontSize]: globalRefs.typography.h2.size,
-			[vars.fontWeight]: globalRefs.typography.h2.weight,
-			[vars.fontFamily]: globalRefs.typography.h2.font
+			[vars$1.fontSize]: globalRefs.typography.h2.size,
+			[vars$1.fontWeight]: globalRefs.typography.h2.weight,
+			[vars$1.fontFamily]: globalRefs.typography.h2.font
 		},
 		h3: {
-			[vars.fontSize]: globalRefs.typography.h3.size,
-			[vars.fontWeight]: globalRefs.typography.h3.weight,
-			[vars.fontFamily]: globalRefs.typography.h3.font
+			[vars$1.fontSize]: globalRefs.typography.h3.size,
+			[vars$1.fontWeight]: globalRefs.typography.h3.weight,
+			[vars$1.fontFamily]: globalRefs.typography.h3.font
 		},
 		subtitle1: {
-			[vars.fontSize]: globalRefs.typography.subtitle1.size,
-			[vars.fontWeight]: globalRefs.typography.subtitle1.weight,
-			[vars.fontFamily]: globalRefs.typography.subtitle1.font
+			[vars$1.fontSize]: globalRefs.typography.subtitle1.size,
+			[vars$1.fontWeight]: globalRefs.typography.subtitle1.weight,
+			[vars$1.fontFamily]: globalRefs.typography.subtitle1.font
 		},
 		subtitle2: {
-			[vars.fontSize]: globalRefs.typography.subtitle2.size,
-			[vars.fontWeight]: globalRefs.typography.subtitle2.weight,
-			[vars.fontFamily]: globalRefs.typography.subtitle2.font
+			[vars$1.fontSize]: globalRefs.typography.subtitle2.size,
+			[vars$1.fontWeight]: globalRefs.typography.subtitle2.weight,
+			[vars$1.fontFamily]: globalRefs.typography.subtitle2.font
 		},
 		body1: {
-			[vars.fontSize]: globalRefs.typography.body1.size,
-			[vars.fontWeight]: globalRefs.typography.body1.weight,
-			[vars.fontFamily]: globalRefs.typography.body1.font
+			[vars$1.fontSize]: globalRefs.typography.body1.size,
+			[vars$1.fontWeight]: globalRefs.typography.body1.weight,
+			[vars$1.fontFamily]: globalRefs.typography.body1.font
 		},
 		body2: {
-			[vars.fontSize]: globalRefs.typography.body2.size,
-			[vars.fontWeight]: globalRefs.typography.body2.weight,
-			[vars.fontFamily]: globalRefs.typography.body2.font
+			[vars$1.fontSize]: globalRefs.typography.body2.size,
+			[vars$1.fontWeight]: globalRefs.typography.body2.weight,
+			[vars$1.fontFamily]: globalRefs.typography.body2.font
 		}
 	},
 	mode: {
 		primary: {
-			[vars.color]: globalRefs.colors.primary.main
+			[vars$1.color]: globalRefs.colors.primary.main
 		},
 		secondary: {
-			[vars.color]: globalRefs.colors.secondary.main
+			[vars$1.color]: globalRefs.colors.secondary.main
 		},
 		error: {
-			[vars.color]: globalRefs.colors.error.main
+			[vars$1.color]: globalRefs.colors.error.main
 		},
 		success: {
-			[vars.color]: globalRefs.colors.success.main
+			[vars$1.color]: globalRefs.colors.success.main
 		}
 	},
 	textAlign: {
-		right: { [vars.textAlign]: 'right' },
-		left: { [vars.textAlign]: 'left' },
-		center: { [vars.textAlign]: 'center' }
+		right: { [vars$1.textAlign]: 'right' },
+		left: { [vars$1.textAlign]: 'left' },
+		center: { [vars$1.textAlign]: 'center' }
 	},
 	_fullWidth: {
-		[vars.width]: '100%',
-		[vars.display]: 'block'
+		[vars$1.width]: '100%',
+		[vars$1.display]: 'block'
 	},
 	_italic: {
-		[vars.fontStyle]: 'italic'
+		[vars$1.fontStyle]: 'italic'
+	},
+	_uppercase: {
+		[vars$1.textTransform]: 'uppercase'
+	},
+	_lowercase: {
+		[vars$1.textTransform]: 'lowercase'
+	}
+};
+
+const vars = Divider.cssVarList;
+
+const divider = {
+	[vars.alignItems]: 'center',
+	[vars.height]: '2px',
+	[vars.backgroundColor]: 'currentColor',
+	[vars.opacity]: '0.2',
+	[vars.padding]: '0 10px',
+	[vars.width]: '100%',
+	[vars.flexDirection]: 'row',
+	[vars.alignSelf]: 'strech',
+	[vars.textWidth]: 'fit-content',
+	_vertical: {
+		[vars.width]: '2px',
+		[vars.padding]: '10px 0',
+		[vars.flexDirection]: 'column',
+		[vars.minHeight]: '200px',
+		[vars.textWidth]: 'max-content'
+	}
+};
+
+const componentName$1 = getComponentName('passcode-internal');
+
+const componentName = getComponentName('passcode');
+
+const customMixin = (superclass) =>
+  class DraggableMixinClass extends superclass {
+    constructor() {
+      super();
+    }
+
+    get digits() {
+      return Number.parseInt(this.getAttribute('digits')) || 6
+    }
+
+    connectedCallback() {
+      super.connectedCallback?.();
+      const template = document.createElement('template');
+
+      //forward required & pattern TODO use forwardAttrs
+      template.innerHTML = `
+      <${componentName$1} 
+        bordered="true" 
+        name="code" 
+        tabindex="0"
+        slot="input"
+        required="${this.shadowRoot.host.getAttribute('required')}"
+        pattern="${this.shadowRoot.host.getAttribute('pattern')}"
+      ></${componentName$1}>
+      `;
+
+      // we are adding a slot under vaadin-text-field, it should reflect all descope-passcode children to be under vaadin-text-field, this is why it has a name & slot
+      const slotEle = Object.assign(document.createElement('slot'), { name: 'input', slot: 'input', part: 'input' });
+      this.proxyElement.appendChild(slotEle);
+
+      // we want to control when the element is out of focus 
+      // so the validations will be triggered blur event is dispatched from descope-passcode internal (and not every time focusing a digit)
+      this.proxyElement._setFocused = () => { };
+
+      this.shadowRoot.host.appendChild(template.content.cloneNode(true));
+      this.inputElement = this.querySelector(componentName$1);
+
+      // we want to trigger validation only when dispatching a blur event from the descope-passcode-internal
+      this.inputElement.addEventListener('blur', () => {
+        this.proxyElement.validate();
+      });
+    }
+  };
+
+const { borderStyle, borderWidth, ...restTextFieldMappings } = textFieldMappings;
+
+const Passcode = compose(
+  createStyleMixin({
+    mappings: {
+      ...restTextFieldMappings,
+    },
+    nestedMappings: {
+      borderColor: {
+        selector: ` ${TextField.componentName}`,
+        property: TextField.cssVarList.borderColor
+      }
+    }
+  }),
+  draggableMixin,
+  inputMixin,
+  componentNameValidationMixin,
+  customMixin
+)(
+  createProxy({
+    slots: [],
+    wrappedEleName: 'vaadin-text-field',
+    style: () => `
+    :host {
+      --vaadin-field-default-width: auto;
+    }
+
+    ::slotted([slot='input']) {
+      -webkit-mask-image: none;
+      display: flex;
+      gap: 2px;
+      align-items: center;
+      padding: 0;
+    }
+
+    vaadin-text-field::part(input-field) {
+      background-color: transparent;
+      padding: 0;
+    }
+
+    ${overrides}
+    `,
+    excludeAttrsSync: ['tabindex'],
+    componentName
+  })
+);
+
+const overrides = `
+	:host {
+		display: inline-block;
 	}
+
+	vaadin-text-field {
+		margin: 0;
+		padding: 0;
+	}
+	vaadin-text-field::part(input-field) {
+		overflow: hidden;
+	}
+	vaadin-text-field[readonly] > input:placeholder-shown {
+		opacity: 1;
+	}
+
+	vaadin-text-field > label,
+	vaadin-text-field::part(input-field) {
+		cursor: pointer;
+		color: var(${Passcode.cssVarList.color});
+	}
+	vaadin-text-field::part(input-field):focus {
+		cursor: text;
+	}
+	vaadin-text-field[required]::part(required-indicator)::after {
+		font-size: "12px";
+		content: "*";
+		color: var(${Passcode.cssVarList.color});
+	}
+	vaadin-text-field[readonly]::part(input-field)::after {
+		border: 0 solid;
+	}
+`;
+
+const passcode = {
+	...textField(Passcode.cssVarList),
 };
 
 var components = {
@@ -1857,7 +2252,9 @@ var components = {
 	switchToggle: swtichToggle,
 	container,
 	logo,
-	text
+	text,
+	divider,
+	passcode
 };
 
 var index = { globals, components };