@vonage/vivid 4.13.0 → 4.14.1

package/shared/anchor.js

@@ -0,0 +1,57 @@
+import { A as ARIAGlobalStatesAndProperties } from './aria-global.js';
+import { a as applyMixins } from './apply-mixins.js';
+import { a as attr } from './vivid-element.js';
+
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+class Anchor {
+}
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr
+], Anchor.prototype, "download");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr
+], Anchor.prototype, "href");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr
+], Anchor.prototype, "hreflang");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr
+], Anchor.prototype, "ping");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr
+], Anchor.prototype, "referrerpolicy");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr
+], Anchor.prototype, "rel");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr
+], Anchor.prototype, "target");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr
+], Anchor.prototype, "type");
+class DelegatesARIALink {
+}
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-expanded" })
+], DelegatesARIALink.prototype, "ariaExpanded");
+applyMixins(DelegatesARIALink, ARIAGlobalStatesAndProperties);
+applyMixins(Anchor, DelegatesARIALink);
+
+export { Anchor as A };

package/shared/anchored.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const index = require('./index.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
       );
-      index.DOM.setBooleanAttribute(
+      vividElement.DOM.setBooleanAttribute(
         this,
         "slotted-anchor",
         isOccupied
@@ -79,17 +79,17 @@ function anchored(constructor) {
     }
   }
   __decorateClass([
-    index.attr
+    vividElement.attr
   ], Decorated.prototype, "anchor");
   __decorateClass([
-    index.observable
+    vividElement.observable
   ], Decorated.prototype, "_slottedAnchor");
   __decorateClass([
-    index.observable
+    vividElement.observable
   ], Decorated.prototype, "_anchorEl");
   return Decorated;
 }
-const anchorSlotTemplateFactory = () => index.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 './index.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;
@@ -89,4 +89,4 @@ function anchored(constructor) {
 }
 const anchorSlotTemplateFactory = () => html`<slot name="anchor" ${slotted("_slottedAnchor")}></slot>`;
 
-export { anchorSlotTemplateFactory as a, anchored as b };
+export { anchored as a, anchorSlotTemplateFactory as b };

package/shared/apply-mixins.cjs

@@ -1,25 +1,23 @@
 'use strict';
 
-const index = require('./index.cjs');
+const vividElement = require('./vivid-element.cjs');
 
-/**
- * Apply mixins to a constructor.
- * Sourced from {@link https://www.typescriptlang.org/docs/handbook/mixins.html | TypeScript Documentation }.
- * @public
- */
 function applyMixins(derivedCtor, ...baseCtors) {
-    const derivedAttributes = index.AttributeConfiguration.locate(derivedCtor);
-    baseCtors.forEach(baseCtor => {
-        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
-            if (name !== "constructor") {
-                Object.defineProperty(derivedCtor.prototype, name, 
-                /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-                Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
-            }
-        });
-        const baseAttributes = index.AttributeConfiguration.locate(baseCtor);
-        baseAttributes.forEach(x => derivedAttributes.push(x));
+  const derivedAttributes = vividElement.AttributeConfiguration.locate(derivedCtor);
+  baseCtors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      if (name !== "constructor") {
+        Object.defineProperty(
+          derivedCtor.prototype,
+          name,
+          /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+          Object.getOwnPropertyDescriptor(baseCtor.prototype, name)
+        );
+      }
     });
+    const baseAttributes = vividElement.AttributeConfiguration.locate(baseCtor);
+    baseAttributes.forEach((x) => derivedAttributes.push(x));
+  });
 }
 
 exports.applyMixins = applyMixins;

package/shared/apply-mixins.js

@@ -1,23 +1,21 @@
-import { A as AttributeConfiguration } from './index.js';
+import { A as AttributeConfiguration } from './vivid-element.js';
 
-/**
- * Apply mixins to a constructor.
- * Sourced from {@link https://www.typescriptlang.org/docs/handbook/mixins.html | TypeScript Documentation }.
- * @public
- */
 function applyMixins(derivedCtor, ...baseCtors) {
-    const derivedAttributes = AttributeConfiguration.locate(derivedCtor);
-    baseCtors.forEach(baseCtor => {
-        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
-            if (name !== "constructor") {
-                Object.defineProperty(derivedCtor.prototype, name, 
-                /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-                Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
-            }
-        });
-        const baseAttributes = AttributeConfiguration.locate(baseCtor);
-        baseAttributes.forEach(x => derivedAttributes.push(x));
+  const derivedAttributes = AttributeConfiguration.locate(derivedCtor);
+  baseCtors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      if (name !== "constructor") {
+        Object.defineProperty(
+          derivedCtor.prototype,
+          name,
+          /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+          Object.getOwnPropertyDescriptor(baseCtor.prototype, name)
+        );
+      }
     });
+    const baseAttributes = AttributeConfiguration.locate(baseCtor);
+    baseAttributes.forEach((x) => derivedAttributes.push(x));
+  });
 }
 
 export { applyMixins as a };

package/shared/apply-mixins2.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const vividElement = require('./vivid-element.cjs');
+
+/**
+ * Apply mixins to a constructor.
+ * Sourced from {@link https://www.typescriptlang.org/docs/handbook/mixins.html | TypeScript Documentation }.
+ * @public
+ */
+function applyMixins(derivedCtor, ...baseCtors) {
+    const derivedAttributes = vividElement.AttributeConfiguration.locate(derivedCtor);
+    baseCtors.forEach(baseCtor => {
+        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
+            if (name !== "constructor") {
+                Object.defineProperty(derivedCtor.prototype, name, 
+                /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+                Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
+            }
+        });
+        const baseAttributes = vividElement.AttributeConfiguration.locate(baseCtor);
+        baseAttributes.forEach(x => derivedAttributes.push(x));
+    });
+}
+
+exports.applyMixins = applyMixins;

package/shared/apply-mixins2.js

@@ -0,0 +1,23 @@
+import { A as AttributeConfiguration } from './vivid-element.js';
+
+/**
+ * Apply mixins to a constructor.
+ * Sourced from {@link https://www.typescriptlang.org/docs/handbook/mixins.html | TypeScript Documentation }.
+ * @public
+ */
+function applyMixins(derivedCtor, ...baseCtors) {
+    const derivedAttributes = AttributeConfiguration.locate(derivedCtor);
+    baseCtors.forEach(baseCtor => {
+        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
+            if (name !== "constructor") {
+                Object.defineProperty(derivedCtor.prototype, name, 
+                /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+                Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
+            }
+        });
+        const baseAttributes = AttributeConfiguration.locate(baseCtor);
+        baseAttributes.forEach(x => derivedAttributes.push(x));
+    });
+}
+
+export { applyMixins as a };

package/shared/applyMixinsWithObservables.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
-const applyMixins = require('./apply-mixins.cjs');
-const index = require('./index.cjs');
+const applyMixins = require('./apply-mixins2.cjs');
+const vividElement = require('./vivid-element.cjs');
 
 function applyMixinsWithObservables(derivedCtor, ...baseCtors) {
   applyMixins.applyMixins(derivedCtor, ...baseCtors);
   baseCtors.forEach((baseCtor) => {
-    index.Observable.getAccessors(baseCtor.prototype).forEach((accessor) => {
-      index.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-mixins.js';
-import { O as Observable } from './index.js';
+import { a as applyMixins } from './apply-mixins2.js';
+import { O as Observable } from './vivid-element.js';
 
 function applyMixinsWithObservables(derivedCtor, ...baseCtors) {
   applyMixins(derivedCtor, ...baseCtors);

package/shared/aria-global.cjs

@@ -1,74 +1,93 @@
 'use strict';
 
-const index = require('./index.cjs');
+const vividElement = require('./vivid-element.cjs');
 
-/**
- * Some states and properties are applicable to all host language elements regardless of whether a role is applied.
- * The following global states and properties are supported by all roles and by all base markup elements.
- * {@link https://www.w3.org/TR/wai-aria-1.1/#global_states}
- *
- * This is intended to be used as a mixin. Be sure you extend FASTElement.
- *
- * @public
- */
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
 class ARIAGlobalStatesAndProperties {
 }
-index.__decorate([
-    index.attr({ attribute: "aria-atomic" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaAtomic", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-busy" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaBusy", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-controls" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaControls", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-current" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaCurrent", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-describedby" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaDescribedby", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-details" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaDetails", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-disabled" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaDisabled", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-errormessage" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaErrormessage", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-flowto" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaFlowto", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-haspopup" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaHaspopup", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-hidden" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaHidden", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-invalid" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaInvalid", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-keyshortcuts" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaKeyshortcuts", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-label" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaLabel", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-labelledby" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaLabelledby", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-live" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaLive", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-owns" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaOwns", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-relevant" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaRelevant", void 0);
-index.__decorate([
-    index.attr({ attribute: "aria-roledescription" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaRoledescription", void 0);
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-atomic" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaAtomic");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-busy" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaBusy");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-controls" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaControls");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-current" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaCurrent");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-describedby" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaDescribedby");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-details" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaDetails");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-disabled" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaDisabled");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-errormessage" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaErrormessage");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-flowto" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaFlowto");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-haspopup" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaHaspopup");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-hidden" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaHidden");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-invalid" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaInvalid");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-keyshortcuts" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaKeyshortcuts");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-label" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaLabel");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-labelledby" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaLabelledby");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-live" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaLive");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-owns" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaOwns");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-relevant" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaRelevant");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  vividElement.attr({ attribute: "aria-roledescription" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaRoledescription");
 
 exports.ARIAGlobalStatesAndProperties = ARIAGlobalStatesAndProperties;

package/shared/aria-global.js

@@ -1,72 +1,91 @@
-import { _ as __decorate, a as attr } from './index.js';
+import { a as attr } from './vivid-element.js';
 
-/**
- * Some states and properties are applicable to all host language elements regardless of whether a role is applied.
- * The following global states and properties are supported by all roles and by all base markup elements.
- * {@link https://www.w3.org/TR/wai-aria-1.1/#global_states}
- *
- * This is intended to be used as a mixin. Be sure you extend FASTElement.
- *
- * @public
- */
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
 class ARIAGlobalStatesAndProperties {
 }
-__decorate([
-    attr({ attribute: "aria-atomic" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaAtomic", void 0);
-__decorate([
-    attr({ attribute: "aria-busy" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaBusy", void 0);
-__decorate([
-    attr({ attribute: "aria-controls" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaControls", void 0);
-__decorate([
-    attr({ attribute: "aria-current" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaCurrent", void 0);
-__decorate([
-    attr({ attribute: "aria-describedby" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaDescribedby", void 0);
-__decorate([
-    attr({ attribute: "aria-details" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaDetails", void 0);
-__decorate([
-    attr({ attribute: "aria-disabled" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaDisabled", void 0);
-__decorate([
-    attr({ attribute: "aria-errormessage" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaErrormessage", void 0);
-__decorate([
-    attr({ attribute: "aria-flowto" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaFlowto", void 0);
-__decorate([
-    attr({ attribute: "aria-haspopup" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaHaspopup", void 0);
-__decorate([
-    attr({ attribute: "aria-hidden" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaHidden", void 0);
-__decorate([
-    attr({ attribute: "aria-invalid" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaInvalid", void 0);
-__decorate([
-    attr({ attribute: "aria-keyshortcuts" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaKeyshortcuts", void 0);
-__decorate([
-    attr({ attribute: "aria-label" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaLabel", void 0);
-__decorate([
-    attr({ attribute: "aria-labelledby" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaLabelledby", void 0);
-__decorate([
-    attr({ attribute: "aria-live" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaLive", void 0);
-__decorate([
-    attr({ attribute: "aria-owns" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaOwns", void 0);
-__decorate([
-    attr({ attribute: "aria-relevant" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaRelevant", void 0);
-__decorate([
-    attr({ attribute: "aria-roledescription" })
-], ARIAGlobalStatesAndProperties.prototype, "ariaRoledescription", void 0);
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-atomic" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaAtomic");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-busy" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaBusy");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-controls" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaControls");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-current" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaCurrent");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-describedby" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaDescribedby");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-details" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaDetails");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-disabled" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaDisabled");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-errormessage" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaErrormessage");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-flowto" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaFlowto");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-haspopup" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaHaspopup");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-hidden" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaHidden");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-invalid" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaInvalid");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-keyshortcuts" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaKeyshortcuts");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-label" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaLabel");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-labelledby" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaLabelledby");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-live" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaLive");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-owns" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaOwns");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-relevant" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaRelevant");
+// @ts-expect-error Type is incorrectly non-optional
+__decorateClass([
+  attr({ attribute: "aria-roledescription" })
+], ARIAGlobalStatesAndProperties.prototype, "ariaRoledescription");
 
 export { ARIAGlobalStatesAndProperties as A };