@vonage/vivid 4.14.0 → 4.14.2

package/shared/anchor.cjs

@@ -2,7 +2,7 @@
 
 const ariaGlobal = require('./aria-global.cjs');
 const applyMixins = require('./apply-mixins.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -17,41 +17,41 @@ class Anchor {
 }
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Anchor.prototype, "download");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Anchor.prototype, "href");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Anchor.prototype, "hreflang");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Anchor.prototype, "ping");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Anchor.prototype, "referrerpolicy");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Anchor.prototype, "rel");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Anchor.prototype, "target");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], Anchor.prototype, "type");
 class DelegatesARIALink {
 }
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-expanded" })
+  vividElement.attr({ attribute: "aria-expanded" })
 ], DelegatesARIALink.prototype, "ariaExpanded");
 applyMixins.applyMixins(DelegatesARIALink, ariaGlobal.ARIAGlobalStatesAndProperties);
 applyMixins.applyMixins(Anchor, DelegatesARIALink);

package/shared/anchor.js

@@ -1,6 +1,6 @@
 import { A as ARIAGlobalStatesAndProperties } from './aria-global.js';
 import { a as applyMixins } from './apply-mixins.js';
-import { a as attr } from './defineVividComponent.js';
+import { a as attr } from './vivid-element.js';
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {

package/shared/anchored.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 const slotted = require('./slotted.cjs');
 
 var __defProp = Object.defineProperty;
@@ -27,7 +27,7 @@ function anchored(constructor) {
       const isOccupied = Boolean(
         this._slottedAnchor && this._slottedAnchor.length > 0
       );
-      defineVividComponent.DOM.setBooleanAttribute(
+      vividElement.DOM.setBooleanAttribute(
         this,
         "slotted-anchor",
         isOccupied
@@ -79,17 +79,17 @@ function anchored(constructor) {
     }
   }
   __decorateClass([
-    defineVividComponent.attr
+    vividElement.attr
   ], Decorated.prototype, "anchor");
   __decorateClass([
-    defineVividComponent.observable
+    vividElement.observable
   ], Decorated.prototype, "_slottedAnchor");
   __decorateClass([
-    defineVividComponent.observable
+    vividElement.observable
   ], Decorated.prototype, "_anchorEl");
   return Decorated;
 }
-const anchorSlotTemplateFactory = () => defineVividComponent.html`<slot name="anchor" ${slotted.slotted("_slottedAnchor")}></slot>`;
+const anchorSlotTemplateFactory = () => vividElement.html`<slot name="anchor" ${slotted.slotted("_slottedAnchor")}></slot>`;
 
 exports.anchorSlotTemplateFactory = anchorSlotTemplateFactory;
 exports.anchored = anchored;

package/shared/anchored.js

@@ -1,4 +1,4 @@
-import { h as html, a as attr, o as observable, D as DOM } from './defineVividComponent.js';
+import { h as html, a as attr, o as observable, D as DOM } from './vivid-element.js';
 import { s as slotted } from './slotted.js';
 
 var __defProp = Object.defineProperty;

package/shared/apply-mixins.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 
 function applyMixins(derivedCtor, ...baseCtors) {
-  const derivedAttributes = defineVividComponent.AttributeConfiguration.locate(derivedCtor);
+  const derivedAttributes = vividElement.AttributeConfiguration.locate(derivedCtor);
   baseCtors.forEach((baseCtor) => {
     Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
       if (name !== "constructor") {
@@ -15,7 +15,7 @@ function applyMixins(derivedCtor, ...baseCtors) {
         );
       }
     });
-    const baseAttributes = defineVividComponent.AttributeConfiguration.locate(baseCtor);
+    const baseAttributes = vividElement.AttributeConfiguration.locate(baseCtor);
     baseAttributes.forEach((x) => derivedAttributes.push(x));
   });
 }

package/shared/apply-mixins.js

@@ -1,4 +1,4 @@
-import { A as AttributeConfiguration } from './defineVividComponent.js';
+import { A as AttributeConfiguration } from './vivid-element.js';
 
 function applyMixins(derivedCtor, ...baseCtors) {
   const derivedAttributes = AttributeConfiguration.locate(derivedCtor);

package/shared/apply-mixins2.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 
 /**
  * Apply mixins to a constructor.
@@ -8,7 +8,7 @@ const defineVividComponent = require('./defineVividComponent.cjs');
  * @public
  */
 function applyMixins(derivedCtor, ...baseCtors) {
-    const derivedAttributes = defineVividComponent.AttributeConfiguration.locate(derivedCtor);
+    const derivedAttributes = vividElement.AttributeConfiguration.locate(derivedCtor);
     baseCtors.forEach(baseCtor => {
         Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
             if (name !== "constructor") {
@@ -17,7 +17,7 @@ function applyMixins(derivedCtor, ...baseCtors) {
                 Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
             }
         });
-        const baseAttributes = defineVividComponent.AttributeConfiguration.locate(baseCtor);
+        const baseAttributes = vividElement.AttributeConfiguration.locate(baseCtor);
         baseAttributes.forEach(x => derivedAttributes.push(x));
     });
 }

package/shared/apply-mixins2.js

@@ -1,4 +1,4 @@
-import { A as AttributeConfiguration } from './defineVividComponent.js';
+import { A as AttributeConfiguration } from './vivid-element.js';
 
 /**
  * Apply mixins to a constructor.

package/shared/applyMixinsWithObservables.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
 const applyMixins = require('./apply-mixins2.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 
 function applyMixinsWithObservables(derivedCtor, ...baseCtors) {
   applyMixins.applyMixins(derivedCtor, ...baseCtors);
   baseCtors.forEach((baseCtor) => {
-    defineVividComponent.Observable.getAccessors(baseCtor.prototype).forEach((accessor) => {
-      defineVividComponent.Observable.defineProperty(derivedCtor.prototype, accessor.name);
+    vividElement.Observable.getAccessors(baseCtor.prototype).forEach((accessor) => {
+      vividElement.Observable.defineProperty(derivedCtor.prototype, accessor.name);
     });
   });
 }

package/shared/applyMixinsWithObservables.js

@@ -1,5 +1,5 @@
 import { a as applyMixins } from './apply-mixins2.js';
-import { O as Observable } from './defineVividComponent.js';
+import { O as Observable } from './vivid-element.js';
 
 function applyMixinsWithObservables(derivedCtor, ...baseCtors) {
   applyMixins(derivedCtor, ...baseCtors);

package/shared/aria-global.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -15,79 +15,79 @@ class ARIAGlobalStatesAndProperties {
 }
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-atomic" })
+  vividElement.attr({ attribute: "aria-atomic" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaAtomic");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-busy" })
+  vividElement.attr({ attribute: "aria-busy" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaBusy");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-controls" })
+  vividElement.attr({ attribute: "aria-controls" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaControls");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-current" })
+  vividElement.attr({ attribute: "aria-current" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaCurrent");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-describedby" })
+  vividElement.attr({ attribute: "aria-describedby" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaDescribedby");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-details" })
+  vividElement.attr({ attribute: "aria-details" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaDetails");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-disabled" })
+  vividElement.attr({ attribute: "aria-disabled" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaDisabled");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-errormessage" })
+  vividElement.attr({ attribute: "aria-errormessage" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaErrormessage");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-flowto" })
+  vividElement.attr({ attribute: "aria-flowto" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaFlowto");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-haspopup" })
+  vividElement.attr({ attribute: "aria-haspopup" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaHaspopup");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-hidden" })
+  vividElement.attr({ attribute: "aria-hidden" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaHidden");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-invalid" })
+  vividElement.attr({ attribute: "aria-invalid" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaInvalid");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-keyshortcuts" })
+  vividElement.attr({ attribute: "aria-keyshortcuts" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaKeyshortcuts");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-label" })
+  vividElement.attr({ attribute: "aria-label" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaLabel");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-labelledby" })
+  vividElement.attr({ attribute: "aria-labelledby" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaLabelledby");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-live" })
+  vividElement.attr({ attribute: "aria-live" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaLive");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-owns" })
+  vividElement.attr({ attribute: "aria-owns" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaOwns");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-relevant" })
+  vividElement.attr({ attribute: "aria-relevant" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaRelevant");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-roledescription" })
+  vividElement.attr({ attribute: "aria-roledescription" })
 ], ARIAGlobalStatesAndProperties.prototype, "ariaRoledescription");
 
 exports.ARIAGlobalStatesAndProperties = ARIAGlobalStatesAndProperties;

package/shared/aria-global.js

@@ -1,4 +1,4 @@
-import { a as attr } from './defineVividComponent.js';
+import { a as attr } from './vivid-element.js';
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {

package/shared/base-progress.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
-const foundationElement = require('./foundation-element.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -12,7 +11,7 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (result) __defProp(target, key, result);
   return result;
 };
-class BaseProgress extends foundationElement.FoundationElement {
+class BaseProgress extends vividElement.VividElement {
   constructor() {
     super(...arguments);
     this.percentComplete = 0;
@@ -58,22 +57,22 @@ class BaseProgress extends foundationElement.FoundationElement {
 }
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ converter: defineVividComponent.nullableNumberConverter })
+  vividElement.attr({ converter: vividElement.nullableNumberConverter })
 ], BaseProgress.prototype, "value");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ converter: defineVividComponent.nullableNumberConverter })
+  vividElement.attr({ converter: vividElement.nullableNumberConverter })
 ], BaseProgress.prototype, "min");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ converter: defineVividComponent.nullableNumberConverter })
+  vividElement.attr({ converter: vividElement.nullableNumberConverter })
 ], BaseProgress.prototype, "max");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr({ mode: "boolean" })
+  vividElement.attr({ mode: "boolean" })
 ], BaseProgress.prototype, "paused");
 __decorateClass([
-  defineVividComponent.observable
+  vividElement.observable
 ], BaseProgress.prototype, "percentComplete");
 
 exports.BaseProgress = BaseProgress;

package/shared/base-progress.js

@@ -1,5 +1,4 @@
-import { F as FoundationElement } from './foundation-element.js';
-import { a as attr, n as nullableNumberConverter, o as observable } from './defineVividComponent.js';
+import { V as VividElement, a as attr, n as nullableNumberConverter, o as observable } from './vivid-element.js';
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -10,7 +9,7 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (result) __defProp(target, key, result);
   return result;
 };
-class BaseProgress extends FoundationElement {
+class BaseProgress extends VividElement {
   constructor() {
     super(...arguments);
     this.percentComplete = 0;

package/shared/breadcrumb-item.cjs

@@ -3,7 +3,6 @@
 const anchor = require('./anchor.cjs');
 const vividElement = require('./vivid-element.cjs');
 const applyMixins = require('./apply-mixins.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -21,10 +20,10 @@ class BreadcrumbItem extends vividElement.VividElement {
   }
 }
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], BreadcrumbItem.prototype, "text");
 __decorateClass([
-  defineVividComponent.observable
+  vividElement.observable
 ], BreadcrumbItem.prototype, "separator");
 applyMixins.applyMixins(BreadcrumbItem, anchor.Anchor);
 

package/shared/breadcrumb-item.js

@@ -1,7 +1,6 @@
 import { A as Anchor } from './anchor.js';
-import { V as VividElement } from './vivid-element.js';
+import { V as VividElement, a as attr, o as observable } from './vivid-element.js';
 import { a as applyMixins } from './apply-mixins.js';
-import { a as attr, o as observable } from './defineVividComponent.js';
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {

package/shared/button.cjs

@@ -4,7 +4,6 @@ const applyMixins = require('./apply-mixins.cjs');
 const formAssociated = require('./form-associated.cjs');
 const vividElement = require('./vivid-element.cjs');
 const ariaGlobal = require('./aria-global.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
 
 class _FoundationButton extends vividElement.VividElement {
 }
@@ -141,36 +140,36 @@ class VividFoundationButton extends FormAssociatedButton {
   }
 }
 __decorateClass([
-  defineVividComponent.attr({ mode: "boolean" })
+  vividElement.attr({ mode: "boolean" })
 ], VividFoundationButton.prototype, "autofocus");
 __decorateClass([
-  defineVividComponent.attr({ attribute: "form" })
+  vividElement.attr({ attribute: "form" })
 ], VividFoundationButton.prototype, "formId");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], VividFoundationButton.prototype, "formaction");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], VividFoundationButton.prototype, "formenctype");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], VividFoundationButton.prototype, "formmethod");
 __decorateClass([
-  defineVividComponent.attr({ mode: "boolean" })
+  vividElement.attr({ mode: "boolean" })
 ], VividFoundationButton.prototype, "formnovalidate");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], VividFoundationButton.prototype, "formtarget");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], VividFoundationButton.prototype, "type");
 class DelegatesARIAButton {
 }
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-expanded" })
+  vividElement.attr({ attribute: "aria-expanded" })
 ], DelegatesARIAButton.prototype, "ariaExpanded");
 __decorateClass([
-  defineVividComponent.attr({ attribute: "aria-pressed" })
+  vividElement.attr({ attribute: "aria-pressed" })
 ], DelegatesARIAButton.prototype, "ariaPressed");
 applyMixins.applyMixins(DelegatesARIAButton, ariaGlobal.ARIAGlobalStatesAndProperties);
 applyMixins.applyMixins(VividFoundationButton, DelegatesARIAButton);

package/shared/button.js

@@ -1,8 +1,7 @@
 import { a as applyMixins } from './apply-mixins.js';
 import { F as FormAssociated } from './form-associated.js';
-import { V as VividElement } from './vivid-element.js';
+import { V as VividElement, a as attr } from './vivid-element.js';
 import { A as ARIAGlobalStatesAndProperties } from './aria-global.js';
-import { a as attr } from './defineVividComponent.js';
 
 class _FoundationButton extends VividElement {
 }

package/shared/calendar-event.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
 const vividElement = require('./vivid-element.cjs');
-const defineVividComponent = require('./defineVividComponent.cjs');
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -16,25 +15,25 @@ class CalendarEvent extends vividElement.VividElement {
   // TODO should be converted to allowed range
 }
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], CalendarEvent.prototype, "heading");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], CalendarEvent.prototype, "description");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], CalendarEvent.prototype, "connotation");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], CalendarEvent.prototype, "appearance");
 __decorateClass([
-  defineVividComponent.attr({ converter: defineVividComponent.nullableNumberConverter, attribute: "overlap-count" })
+  vividElement.attr({ converter: vividElement.nullableNumberConverter, attribute: "overlap-count" })
 ], CalendarEvent.prototype, "overlapCount");
 __decorateClass([
-  defineVividComponent.attr({ converter: defineVividComponent.nullableNumberConverter })
+  vividElement.attr({ converter: vividElement.nullableNumberConverter })
 ], CalendarEvent.prototype, "start");
 __decorateClass([
-  defineVividComponent.attr({ converter: defineVividComponent.nullableNumberConverter })
+  vividElement.attr({ converter: vividElement.nullableNumberConverter })
 ], CalendarEvent.prototype, "duration");
 
 exports.CalendarEvent = CalendarEvent;

package/shared/calendar-event.js

@@ -1,5 +1,4 @@
-import { V as VividElement } from './vivid-element.js';
-import { a as attr, n as nullableNumberConverter } from './defineVividComponent.js';
+import { V as VividElement, a as attr, n as nullableNumberConverter } from './vivid-element.js';
 
 var __defProp = Object.defineProperty;
 var __decorateClass = (decorators, target, key, kind) => {

package/shared/children.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 const slotted = require('./slotted.cjs');
 
 /**
@@ -55,7 +55,7 @@ function children(propertyOrOptions) {
             property: propertyOrOptions,
         };
     }
-    return new defineVividComponent.AttachedBehaviorHTMLDirective("fast-children", ChildrenBehavior, propertyOrOptions);
+    return new vividElement.AttachedBehaviorHTMLDirective("fast-children", ChildrenBehavior, propertyOrOptions);
 }
 
 exports.children = children;

package/shared/children.js

@@ -1,4 +1,4 @@
-import { b as AttachedBehaviorHTMLDirective } from './defineVividComponent.js';
+import { b as AttachedBehaviorHTMLDirective } from './vivid-element.js';
 import { N as NodeObservationBehavior } from './slotted.js';
 
 /**

package/shared/definition.cjs

@@ -1,10 +1,9 @@
 'use strict';
 
-const defineVividComponent = require('./defineVividComponent.cjs');
+const vividElement = require('./vivid-element.cjs');
 const definition = require('./definition27.cjs');
 const affix = require('./affix.cjs');
 const applyMixins = require('./apply-mixins.cjs');
-const vividElement = require('./vivid-element.cjs');
 const ref = require('./ref.cjs');
 const when = require('./when.cjs');
 
@@ -38,36 +37,36 @@ class AccordionItem extends vividElement.VividElement {
   }
 }
 __decorateClass([
-  defineVividComponent.attr({
+  vividElement.attr({
     attribute: "heading-level",
     mode: "fromView",
-    converter: defineVividComponent.nullableNumberConverter
+    converter: vividElement.nullableNumberConverter
   })
 ], AccordionItem.prototype, "headinglevel");
 __decorateClass([
-  defineVividComponent.attr({ mode: "boolean" })
+  vividElement.attr({ mode: "boolean" })
 ], AccordionItem.prototype, "expanded");
 // @ts-expect-error Type is incorrectly non-optional
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], AccordionItem.prototype, "id");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], AccordionItem.prototype, "heading");
 __decorateClass([
-  defineVividComponent.attr({ mode: "boolean", attribute: "no-indicator" })
+  vividElement.attr({ mode: "boolean", attribute: "no-indicator" })
 ], AccordionItem.prototype, "noIndicator");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], AccordionItem.prototype, "meta");
 __decorateClass([
-  defineVividComponent.attr
+  vividElement.attr
 ], AccordionItem.prototype, "size");
 applyMixins.applyMixins(AccordionItem, affix.AffixIconWithTrailing);
 
 const header = (context, hTag) => {
   const affixIconTemplate = affix.affixIconTemplateFactory(context);
-  return defineVividComponent.html`
+  return vividElement.html`
 		<${hTag} class="heading-container">
 			<button
 				class="heading-button ${(x) => x.size ? `size-${x.size}` : ""}"
@@ -82,7 +81,7 @@ const header = (context, hTag) => {
 
 				<span class="heading-content">${(x) => x.heading}</span>
 
-				${when.when((x) => x.meta, defineVividComponent.html`<span class="meta">${(x) => x.meta}</span>`)}
+				${when.when((x) => x.meta, vividElement.html`<span class="meta">${(x) => x.meta}</span>`)}
 
 				${(x) => x.icon && x.iconTrailing ? affixIconTemplate(x.icon) : null}
 				${(x) => !(x.icon && x.iconTrailing) && !x.noIndicator ? affixIconTemplate(
@@ -93,7 +92,7 @@ const header = (context, hTag) => {
 		</${hTag}>
 	`;
 };
-const AccordionItemTemplate = (context) => defineVividComponent.html`
+const AccordionItemTemplate = (context) => vividElement.html`
 	${(x) => header(context, "h" + x.headinglevel)}
 	<div
 		id="${(x) => x.id}-panel"
@@ -105,7 +104,7 @@ const AccordionItemTemplate = (context) => defineVividComponent.html`
 	</div>
 `;
 
-const accordionItemDefinition = defineVividComponent.defineVividComponent(
+const accordionItemDefinition = vividElement.defineVividComponent(
   "accordion-item",
   AccordionItem,
   AccordionItemTemplate,
@@ -114,7 +113,7 @@ const accordionItemDefinition = defineVividComponent.defineVividComponent(
     styles
   }
 );
-const registerAccordionItem = defineVividComponent.createRegisterFunction(
+const registerAccordionItem = vividElement.createRegisterFunction(
   accordionItemDefinition
 );