@vonage/vivid 4.14.0 → 4.14.1

package/shared/definition11.cjs

@@ -2,7 +2,7 @@
 
 const definition = require('./definition27.cjs');
 const definition$1 = require('./definition37.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 const affix = require('./affix.cjs');
 const button = require('./button.cjs');
 const applyMixins = require('./apply-mixins.cjs');
@@ -31,7 +31,7 @@ class Button extends button.VividFoundationButton {
   }
 }
 __decorateClass([
-  defineVividComponent.attr({
+  vividElement.attr({
     converter: {
       fromView: (value) => value || null,
       toView: (value) => value || null
@@ -39,64 +39,64 @@ __decorateClass([
   })
 ], Button.prototype, "title");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "connotation");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "shape");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "appearance");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "size");
 __decorateClass([
-  defineVividComponent.attr({
+  vividElement.attr({
     mode: "boolean",
     attribute: "stacked"
   })
 ], Button.prototype, "stacked");
 __decorateClass([
-  defineVividComponent.attr({
+  vividElement.attr({
     mode: "boolean",
     attribute: "pending"
   })
 ], Button.prototype, "pending");
 __decorateClass([
-  defineVividComponent.attr({
+  vividElement.attr({
     mode: "boolean",
     attribute: "dropdown-indicator"
   })
 ], Button.prototype, "dropdownIndicator");
 __decorateClass([
-  defineVividComponent.attr({
+  vividElement.attr({
     mode: "boolean",
     attribute: "active"
   })
 ], Button.prototype, "active");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "label");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "href");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "download");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "hreflang");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "ping");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "referrerpolicy");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "rel");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Button.prototype, "target");
 applyMixins.applyMixins(Button, affix.AffixIconWithTrailing);
 
@@ -104,7 +104,7 @@ const styles = ".chevron{display:flex;flex-shrink:0;font:var(--vvd-typography-ba
 
 const chevronTemplateFactory = (context) => {
   const iconTag = context.tagFor(definition.Icon);
-  return defineVividComponent.html`<${iconTag} class="chevron" aria-hidden="true" name="chevron-down-line"></${iconTag}>`;
+  return vividElement.html`<${iconTag} class="chevron" aria-hidden="true" name="chevron-down-line"></${iconTag}>`;
 };
 
 const getAppearanceClassName = (appearance, disabled) => {
@@ -151,7 +151,7 @@ function renderIconOrPending(context, icon, pending, size = enums.Size.Normal) {
       [enums.Size.Normal]: "-5",
       [enums.Size.Expanded]: "-4"
     };
-    return defineVividComponent.html`<span class="icon pending"><${progressTag} size="${progressSize[size]}"></${progressTag}></span>`;
+    return vividElement.html`<span class="icon pending"><${progressTag} size="${progressSize[size]}"></${progressTag}></span>`;
   } else {
     const affixIconTemplate = affix.affixIconTemplateFactory(context);
     return affixIconTemplate(icon, affix.IconWrapper.Slot);
@@ -159,17 +159,17 @@ function renderIconOrPending(context, icon, pending, size = enums.Size.Normal) {
 }
 const buttonContent = (context) => {
   const chevronTemplate = chevronTemplateFactory(context);
-  return defineVividComponent.html`<span class="content">
+  return vividElement.html`<span class="content">
 			${(x) => renderIconOrPending(context, x.icon, x.pending, x.size)}
 			${when.when(
     (x) => x.label,
-    defineVividComponent.html`<span class="text" role="presentation">${(x) => x.label}</span>`
+    vividElement.html`<span class="text" role="presentation">${(x) => x.label}</span>`
   )}
 		</span>
 		${when.when((x) => x.dropdownIndicator, chevronTemplate)}`;
 };
 function renderButtonContent(context) {
-  return defineVividComponent.html` <button
+  return vividElement.html` <button
 		class="${getClasses}"
 		?autofocus="${(x) => x.autofocus}"
 		?disabled="${(x) => x.disabled || x.pending}"
@@ -204,7 +204,7 @@ function renderButtonContent(context) {
 	</button>`;
 }
 function renderAnchorContent(context) {
-  return defineVividComponent.html`<a
+  return vividElement.html`<a
 		class="${getClasses}"
 		download="${(x) => x.download}"
 		href="${(x) => x.href}"
@@ -235,13 +235,13 @@ function renderAnchorContent(context) {
 	</a>`;
 }
 const buttonTemplate = (context) => {
-  return defineVividComponent.html` <template role="presentation">
-		${when.when((x) => !x.href, defineVividComponent.html`${renderButtonContent(context)}`)}
-		${when.when((x) => x.href, defineVividComponent.html`${renderAnchorContent(context)}`)}
+  return vividElement.html` <template role="presentation">
+		${when.when((x) => !x.href, vividElement.html`${renderButtonContent(context)}`)}
+		${when.when((x) => x.href, vividElement.html`${renderAnchorContent(context)}`)}
 	</template>`;
 };
 
-const buttonDefinition = defineVividComponent.defineVividComponent(
+const buttonDefinition = vividElement.defineVividComponent(
   "button",
   Button,
   buttonTemplate,
@@ -253,7 +253,7 @@ const buttonDefinition = defineVividComponent.defineVividComponent(
     }
   }
 );
-const registerButton = defineVividComponent.createRegisterFunction(buttonDefinition);
+const registerButton = vividElement.createRegisterFunction(buttonDefinition);
 
 exports.Button = Button;
 exports.buttonDefinition = buttonDefinition;

package/shared/definition11.js

@@ -1,6 +1,6 @@
 import { I as Icon, i as iconDefinition } from './definition27.js';
 import { P as ProgressRing, p as progressRingDefinition } from './definition37.js';
-import { a as attr, h as html, d as defineVividComponent, f as createRegisterFunction } from './defineVividComponent.js';
+import { a as attr, h as html, d as defineVividComponent, f as createRegisterFunction } from './vivid-element.js';
 import { b as AffixIconWithTrailing, a as affixIconTemplateFactory, I as IconWrapper } from './affix.js';
 import { V as VividFoundationButton } from './button.js';
 import { a as applyMixins } from './apply-mixins.js';

package/shared/definition12.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 const calendarEvent = require('./calendar-event.cjs');
 const when = require('./when.cjs');
 const classNames = require('./class-names.cjs');
@@ -22,17 +22,17 @@ const getStyles = ({ start, duration, overlapCount }) => {
   };
   return Object.entries(stylesObj).map((entry) => entry.join(":")).join(";");
 };
-const CalendarEventTemplate = defineVividComponent.html` <div
+const CalendarEventTemplate = vividElement.html` <div
 	style="${getStyles}"
 	class="${getClasses}"
 	role="button"
 	tabindex="0"
 >
-	${when.when((x) => x.heading, defineVividComponent.html`<h2><strong>${(x) => x.heading}</strong></h2>`)}
-	${when.when((x) => x.description, defineVividComponent.html`<p>${(x) => x.description}</p>`)}
+	${when.when((x) => x.heading, vividElement.html`<h2><strong>${(x) => x.heading}</strong></h2>`)}
+	${when.when((x) => x.description, vividElement.html`<p>${(x) => x.description}</p>`)}
 </div>`;
 
-const calendarEventDefinition = defineVividComponent.defineVividComponent(
+const calendarEventDefinition = vividElement.defineVividComponent(
   "calendar-event",
   calendarEvent.CalendarEvent,
   CalendarEventTemplate,
@@ -44,7 +44,7 @@ const calendarEventDefinition = defineVividComponent.defineVividComponent(
     }
   }
 );
-const registerCalendarEvent = defineVividComponent.createRegisterFunction(
+const registerCalendarEvent = vividElement.createRegisterFunction(
   calendarEventDefinition
 );
 

package/shared/definition12.js

@@ -1,4 +1,4 @@
-import { h as html, d as defineVividComponent, f as createRegisterFunction } from './defineVividComponent.js';
+import { h as html, d as defineVividComponent, f as createRegisterFunction } from './vivid-element.js';
 import { C as CalendarEvent } from './calendar-event.js';
 import { w as when } from './when.js';
 import { c as classNames } from './class-names.js';

package/shared/definition13.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-const defineVividComponent = require('./defineVividComponent.cjs');
 const vividElement = require('./vivid-element.cjs');
 const calendarEvent = require('./calendar-event.cjs');
 const _has = require('./_has.cjs');
@@ -687,16 +686,16 @@ class Calendar extends vividElement.VividElement {
   }
 }
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Calendar.prototype, "datetime");
 __decorateClass([
-  defineVividComponent.attr({ attribute: "start-day" })
+  vividElement.attr({ attribute: "start-day" })
 ], Calendar.prototype, "startDay");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Calendar.prototype, "locales");
 __decorateClass([
-  defineVividComponent.attr({ mode: "boolean" })
+  vividElement.attr({ mode: "boolean" })
 ], Calendar.prototype, "hour12");
 
 function getValidDateString(date) {
@@ -718,10 +717,10 @@ function getFirstDateOfTheWeek(date = /* @__PURE__ */ new Date(), startDay) {
 }
 
 const HoursTemplate = () => {
-  return defineVividComponent.html` <div class="row-headers" role="row">
+  return vividElement.html` <div class="row-headers" role="row">
 		${repeat.repeat(
     (x) => x.hoursAsDatetime,
-    defineVividComponent.html`<span role="rowheader">
+    vividElement.html`<span role="rowheader">
 				<time
 					datetime="${(x, c) => new Intl.DateTimeFormat(c.parent.locales, {
       hour: "numeric",
@@ -739,10 +738,10 @@ const HoursTemplate = () => {
 	</div>`;
 };
 const DaysTemplate = () => {
-  return defineVividComponent.html` <div class="column-headers" role="row">
+  return vividElement.html` <div class="column-headers" role="row">
 		${repeat.repeat(
     (x) => x._generateDaysArr([getFirstDateOfTheWeek(x.datetime, x.startDay)]),
-    defineVividComponent.html` <div role="columnheader" tabindex="-1">
+    vividElement.html` <div role="columnheader" tabindex="-1">
 				<time datetime=${(x) => getValidDateString(x)}>
 					<h2>
 						<!-- TODO add to column aria-labelledby or describedby to count
@@ -771,12 +770,12 @@ const DaysTemplate = () => {
   )}
 	</div>`;
 };
-const ColumnTemplate = defineVividComponent.html`
+const ColumnTemplate = vividElement.html`
 	<div role="gridcell" tabindex="-1">
 		<slot name="day-${(_, c) => c.index}"></slot>
 	</div>
 `;
-const CalendarTemplate = defineVividComponent.html`
+const CalendarTemplate = vividElement.html`
 	<div role="grid" @keydown=${(x, c) => x.onKeydown(c.event)}>
 		${DaysTemplate}
 		<div class="calendar-row" role="rowgroup">
@@ -785,7 +784,7 @@ const CalendarTemplate = defineVividComponent.html`
 				<div class="hours" role="list">
 					${repeat.repeat(
   (x) => Array.from({ length: x.hoursAsDatetime.length + 1 }),
-  defineVividComponent.html` <div role="listitem"></div>`
+  vividElement.html` <div role="listitem"></div>`
 )}
 				</div>
 				<div class="columns" role="row">
@@ -799,7 +798,7 @@ const CalendarTemplate = defineVividComponent.html`
 	</div>
 `;
 
-const calendarDefinition = defineVividComponent.defineVividComponent(
+const calendarDefinition = vividElement.defineVividComponent(
   "calendar",
   Calendar,
   CalendarTemplate,
@@ -811,7 +810,7 @@ const calendarDefinition = defineVividComponent.defineVividComponent(
     }
   }
 );
-const registerCalendar = defineVividComponent.createRegisterFunction(calendarDefinition);
+const registerCalendar = vividElement.createRegisterFunction(calendarDefinition);
 
 exports.calendarDefinition = calendarDefinition;
 exports.registerCalendar = registerCalendar;

package/shared/definition13.js

@@ -1,5 +1,4 @@
-import { a as attr, h as html, d as defineVividComponent, f as createRegisterFunction } from './defineVividComponent.js';
-import { V as VividElement } from './vivid-element.js';
+import { V as VividElement, a as attr, h as html, d as defineVividComponent, f as createRegisterFunction } from './vivid-element.js';
 import { C as CalendarEvent } from './calendar-event.js';
 import { b as _has, _ as _curry1, a as _curry2 } from './_has.js';
 import { r as repeat } from './repeat.js';

package/shared/definition14.cjs

@@ -2,7 +2,6 @@
 
 const definition$1 = require('./definition27.cjs');
 const definition = require('./definition62.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
 const vividElement = require('./vivid-element.cjs');
 const enums = require('./enums.cjs');
 const when = require('./when.cjs');
@@ -23,31 +22,31 @@ var __decorateClass = (decorators, target, key, kind) => {
 class Card extends vividElement.VividElement {
 }
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Card.prototype, "appearance");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Card.prototype, "headline");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Card.prototype, "subtitle");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Card.prototype, "text");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Card.prototype, "icon");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Card.prototype, "elevation");
 __decorateClass([
-  defineVividComponent.observable
+  vividElement.observable
 ], Card.prototype, "footerSlottedContent");
 __decorateClass([
-  defineVividComponent.observable
+  vividElement.observable
 ], Card.prototype, "graphicSlottedContent");
 __decorateClass([
-  defineVividComponent.observable
+  vividElement.observable
 ], Card.prototype, "hasMetaSlottedContent");
 
 const getClasses = (_) => classNames.classNames(
@@ -56,17 +55,17 @@ const getClasses = (_) => classNames.classNames(
   ["hide-header", shouldHideHeader(_)]
 );
 function renderHeaderIcon(iconTag) {
-  return defineVividComponent.html`
+  return vividElement.html`
 		<${iconTag} class="icon" inline name="${(x) => x.icon}"></${iconTag}>`;
 }
 function Headline() {
-  return defineVividComponent.html` <div class="header-headline">${(x) => x.headline}</div> `;
+  return vividElement.html` <div class="header-headline">${(x) => x.headline}</div> `;
 }
 function Subtitle() {
-  return defineVividComponent.html` <div class="header-subtitle">${(x) => x.subtitle}</div> `;
+  return vividElement.html` <div class="header-subtitle">${(x) => x.subtitle}</div> `;
 }
 function headerContent() {
-  return defineVividComponent.html`
+  return vividElement.html`
 		<div class="header-content">
 			${when.when((x) => x.headline, Headline())}
 			${when.when((x) => x.subtitle, Subtitle())}
@@ -74,7 +73,7 @@ function headerContent() {
 	`;
 }
 function renderHeader(iconTag) {
-  return defineVividComponent.html` <header class="header">
+  return vividElement.html` <header class="header">
 		<slot name="graphic" ${slotted.slotted("graphicSlottedContent")}
 			>${when.when((x) => x.icon, renderHeaderIcon(iconTag))}</slot
 		>
@@ -85,14 +84,14 @@ function shouldHideHeader(card) {
   return !card.headline && !card.subtitle && !card.icon && (!card.graphicSlottedContent || !card.graphicSlottedContent.length);
 }
 function renderMetaSlot() {
-  return defineVividComponent.html` <slot name="meta" ${slotted.slotted("metaSlottedContent")}></slot> `;
+  return vividElement.html` <slot name="meta" ${slotted.slotted("metaSlottedContent")}></slot> `;
 }
 function text() {
-  return defineVividComponent.html` <div class="text">${(x) => x.text}</div> `;
+  return vividElement.html` <div class="text">${(x) => x.text}</div> `;
 }
 function renderCardContent(context) {
   const iconTag = context.tagFor(definition$1.Icon);
-  return defineVividComponent.html`
+  return vividElement.html`
 		<div class="${getClasses}">
 			<div class="wrapper">
 				<div class="vwc-card-media">
@@ -115,10 +114,10 @@ function renderCardContent(context) {
 }
 const CardTemplate = (context) => {
   const elevationTag = context.tagFor(definition.Elevation);
-  return defineVividComponent.html`
+  return vividElement.html`
 		${when.when(
     (x) => x.appearance !== enums.Appearance.Ghost && x.appearance !== enums.Appearance.Outlined,
-    defineVividComponent.html`
+    vividElement.html`
 			<${elevationTag} dp=${(x) => x.elevation ?? "4"}>
 			  ${renderCardContent(context)}
 			</${elevationTag}>
@@ -126,7 +125,7 @@ const CardTemplate = (context) => {
   )}
 		${when.when(
     (x) => x.appearance === enums.Appearance.Outlined,
-    defineVividComponent.html`
+    vividElement.html`
 			<${elevationTag} dp='0')}>
 			  ${renderCardContent(context)}
 			</${elevationTag}>
@@ -134,12 +133,12 @@ const CardTemplate = (context) => {
   )}
 		${when.when(
     (x) => x.appearance === enums.Appearance.Ghost,
-    defineVividComponent.html` ${renderCardContent(context)} `
+    vividElement.html` ${renderCardContent(context)} `
   )}
 	`;
 };
 
-const cardDefinition = defineVividComponent.defineVividComponent(
+const cardDefinition = vividElement.defineVividComponent(
   "card",
   Card,
   CardTemplate,
@@ -148,7 +147,7 @@ const cardDefinition = defineVividComponent.defineVividComponent(
     styles
   }
 );
-const registerCard = defineVividComponent.createRegisterFunction(cardDefinition);
+const registerCard = vividElement.createRegisterFunction(cardDefinition);
 
 exports.cardDefinition = cardDefinition;
 exports.registerCard = registerCard;

package/shared/definition14.js

@@ -1,7 +1,6 @@
 import { I as Icon, i as iconDefinition } from './definition27.js';
 import { E as Elevation, e as elevationDefinition } from './definition62.js';
-import { a as attr, o as observable, h as html, d as defineVividComponent, f as createRegisterFunction } from './defineVividComponent.js';
-import { V as VividElement } from './vivid-element.js';
+import { V as VividElement, a as attr, o as observable, h as html, d as defineVividComponent, f as createRegisterFunction } from './vivid-element.js';
 import { A as Appearance } from './enums.js';
 import { w as when } from './when.js';
 import { s as slotted } from './slotted.js';

package/shared/definition15.cjs

@@ -1,10 +1,9 @@
 'use strict';
 
 const definition = require('./definition27.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 const applyMixinsWithObservables = require('./applyMixinsWithObservables.cjs');
 const formAssociated = require('./form-associated.cjs');
-const vividElement = require('./vivid-element.cjs');
 const formElements = require('./form-elements.cjs');
 const when = require('./when.cjs');
 const slotted = require('./slotted.cjs');
@@ -112,28 +111,28 @@ exports.Checkbox = class Checkbox extends FormAssociatedCheckbox {
   }
 };
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-label" })
+  vividElement.attr({ attribute: "aria-label" })
 ], exports.Checkbox.prototype, "ariaLabel", 2);
 __decorateClass([
-  defineVividComponent.attr({ attribute: "tabindex" })
+  vividElement.attr({ attribute: "tabindex" })
 ], exports.Checkbox.prototype, "tabindex", 2);
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], exports.Checkbox.prototype, "connotation", 2);
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-checked" })
+  vividElement.attr({ attribute: "aria-checked" })
 ], exports.Checkbox.prototype, "ariaChecked", 2);
 __decorateClass([
-  defineVividComponent.attr({ attribute: "readonly", mode: "boolean" })
+  vividElement.attr({ attribute: "readonly", mode: "boolean" })
 ], exports.Checkbox.prototype, "readOnly", 2);
 __decorateClass([
-  defineVividComponent.observable
+  vividElement.observable
 ], exports.Checkbox.prototype, "defaultSlottedNodes", 2);
 __decorateClass([
-  defineVividComponent.observable
+  vividElement.observable
 ], exports.Checkbox.prototype, "indeterminate", 2);
 __decorateClass([
-  defineVividComponent.observable
+  vividElement.observable
 ], exports.Checkbox.prototype, "slottedContent", 2);
 exports.Checkbox = __decorateClass([
   formElements.errorText,
@@ -167,7 +166,7 @@ const getClasses = ({
 );
 const CheckboxTemplate = (context) => {
   const iconTag = context.tagFor(definition.Icon);
-  return defineVividComponent.html`<template role="${(x) => x.ariaLabel ? "presentation" : null}">
+  return vividElement.html`<template role="${(x) => x.ariaLabel ? "presentation" : null}">
 		<div
 			class="${getClasses}"
 			role="checkbox"
@@ -183,14 +182,14 @@ const CheckboxTemplate = (context) => {
 			<div class="control">
 				${when.when(
     (x) => x.checked,
-    defineVividComponent.html`<${iconTag} name="check-solid" class="icon"></${iconTag}>`
+    vividElement.html`<${iconTag} name="check-solid" class="icon"></${iconTag}>`
   )}
 				${when.when(
     (x) => x.indeterminate,
-    defineVividComponent.html`<${iconTag} name="minus-solid" class="icon"></${iconTag}>`
+    vividElement.html`<${iconTag} name="minus-solid" class="icon"></${iconTag}>`
   )}
 			</div>
-			${defineVividComponent.html`<label
+			${vividElement.html`<label
 				>${(x) => x.label}<slot ${slotted.slotted("slottedContent")}></slot
 			></label>`}
 		</div>
@@ -198,7 +197,7 @@ const CheckboxTemplate = (context) => {
 	</template>`;
 };
 
-const checkboxDefinition = defineVividComponent.defineVividComponent(
+const checkboxDefinition = vividElement.defineVividComponent(
   "checkbox",
   exports.Checkbox,
   CheckboxTemplate,
@@ -210,7 +209,7 @@ const checkboxDefinition = defineVividComponent.defineVividComponent(
     }
   }
 );
-const registerCheckbox = defineVividComponent.createRegisterFunction(checkboxDefinition);
+const registerCheckbox = vividElement.createRegisterFunction(checkboxDefinition);
 
 exports.checkboxDefinition = checkboxDefinition;
 exports.registerCheckbox = registerCheckbox;

package/shared/definition15.js

@@ -1,8 +1,7 @@
 import { I as Icon, i as iconDefinition } from './definition27.js';
-import { a as attr, o as observable, h as html, d as defineVividComponent, f as createRegisterFunction } from './defineVividComponent.js';
+import { V as VividElement, a as attr, o as observable, h as html, d as defineVividComponent, f as createRegisterFunction } from './vivid-element.js';
 import { a as applyMixinsWithObservables } from './applyMixinsWithObservables.js';
 import { C as CheckableFormAssociated } from './form-associated.js';
-import { V as VividElement } from './vivid-element.js';
 import { e as errorText, f as formElements, F as FormElementSuccessText, a as FormElementHelperText, g as getFeedbackTemplate } from './form-elements.js';
 import { w as when } from './when.js';
 import { s as slotted } from './slotted.js';