@globalpayments/vega 2.77.0 → 2.77.1

package/dist/esm/{element-appender-slimmer-9ea377d0.js → element-appender-slimmer-5d573612.js}

@@ -4,8 +4,8 @@ import { I as InternalVegaZIndexManager } from './internal-vega-z-index-manager-
 import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
 import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-d6af0d86.js';
 import { A as Alignments, P as Placements } from './ui-28fd4193.js';
-import { H as isTranslocationType, a3 as isEATriggerStrategy } from './type-guard-f50e34d6.js';
-import { R as ResponsiveFormatFacade } from './responsive-format-facade-aa705823.js';
+import { H as isTranslocationType, i as isNonNullable, a4 as isEATriggerStrategy } from './type-guard-af324dcd.js';
+import { R as ResponsiveFormatFacade } from './responsive-format-facade-2a36c54a.js';
 import { t as tryGetDocument } from './try-get-document-bef0f526.js';
 import { F as FeatureFlag } from './feature-flag-controller-30f7b625.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
@@ -290,19 +290,24 @@ class BasePositionCalculationStrategy extends VegaSlimmer {
    * returns an ElementPositionBox.
    */
   getPositionBox(placement, alignment) {
-    const placements = placement || this.getPlacements();
-    const alignments = alignment || this.getAlignments();
+    const placements = placement && placement.length > 0 ? placement : this.getPlacements();
+    const alignments = alignment && alignment.length > 0 ? alignment : this.getAlignments();
     const targetBox = this.getTargetBoundBox();
     const elementBox = this.getElementBoundBox();
     const containerBox = this.getElementScrollDimension();
     const suitablePlacement = this.getSuitablePlacement(containerBox, elementBox, targetBox, placements);
-    const suitableAlignment = this.getSuitableAlignment(containerBox, elementBox, targetBox, suitablePlacement, alignments);
-    const positionBox = this.calculatePosition(elementBox, targetBox, suitablePlacement, suitableAlignment);
-    const translocationBox = this.getTranslocationBox(suitablePlacement);
+    const activePlacement = suitablePlacement || placements[0];
+    const suitableAlignment = this.getSuitableAlignment(containerBox, elementBox, targetBox, activePlacement, alignments);
+    const activeAlignment = suitableAlignment || alignments[0];
+    const positionBox = this.calculatePosition(elementBox, targetBox, activePlacement, activeAlignment);
+    const translocationBox = this.getTranslocationBox(activePlacement);
     positionBox.placement = suitablePlacement;
     positionBox.alignment = suitableAlignment;
     positionBox.left += translocationBox.X;
     positionBox.top += translocationBox.Y;
+    if (!this.showConfig.positionRelativeTo) {
+      this.adjustPositionForViewport(positionBox, elementBox, targetBox, activePlacement);
+    }
     return positionBox;
   }
   /**
@@ -441,7 +446,7 @@ class BasePositionCalculationStrategy extends VegaSlimmer {
    * @param {ElementBoundBox} elementBox - The box of the element to be placed.
    * @param {ElementBoundBox} targetBox - The box of the target element.
    * @param {PlacementType[]} placements - The placements that we want to try.
-   * @returns {PlacementType} A function that takes in a containerBox, elementBox, targetBox, placements, and element.
+   * @returns {Nullable<PlacementType>} A function that takes in a containerBox, elementBox, targetBox, placements, and element.
    */
   getSuitablePlacement(containerBox, elementBox, targetBox, placements) {
     const defaultPlacement = placements[0];
@@ -454,7 +459,7 @@ class BasePositionCalculationStrategy extends VegaSlimmer {
                 No enough space found for placing element and we will keep using the defined placement:
                 ${defaultPlacement}
             `);
-      return defaultPlacement;
+      return null;
     }
   }
   /**
@@ -520,6 +525,115 @@ class BasePositionCalculationStrategy extends VegaSlimmer {
       left: this.calculateLeft(elementBox, targetBox, placement, alignment),
     };
   }
+  /**
+   * Keeps the vertical position within the visible viewport
+   *
+   * @param {number} top - The calculated top position.
+   * @param {number} elementHeight - The height of the element.
+   * @returns {number} The top position constrained to the viewport.
+   */
+  keepVerticallyInView(top, elementHeight) {
+    return Math.max(0, Math.min(top, window.innerHeight - elementHeight));
+  }
+  /**
+   * Keeps the horizontal position within the visible viewport
+   *
+   * @param {number} left - The calculated left position.
+   * @param {number} elementWidth - The width of the element.
+   * @returns {number} The left position constrained to the viewport.
+   */
+  keepHorizontallyInView(left, elementWidth) {
+    return Math.max(0, Math.min(left, window.innerWidth - elementWidth));
+  }
+  /**
+   * Checks if the target element is visible in the viewport
+   *
+   * @param {ElementBoundBox} targetBox - The bounding box of the target element.
+   * @returns {boolean} True if target is visible in viewport.
+   */
+  isTargetInView(targetBox) {
+    const innerHeight = window.innerHeight;
+    const innerWidth = window.innerWidth;
+    const targetBottom = targetBox.top + targetBox.height;
+    const targetRight = targetBox.left + targetBox.width;
+    return (targetBox.top <= innerHeight &&
+      targetBottom >= 0 &&
+      targetBox.left <= innerWidth &&
+      targetRight >= 0);
+  }
+  /**
+   * Corrects `positionBox` so the element stays within the viewport after translocation.
+   * Only runs when the target is visible; skips correction entirely if the target has
+   * scrolled out of view so the element simply follows it.
+   *
+   * @param {ElementPositionBox} positionBox - The final position box to adjust (mutated in place).
+   * @param {ElementBoundBox} elementBox - Dimensions of the positioned element.
+   * @param {ElementBoundBox} targetBox - Bounding box of the target element.
+   * @param {PlacementType} placement - Active placement used to select the correction axis.
+   */
+  adjustPositionForViewport(positionBox, elementBox, targetBox, placement) {
+    if (!this.isTargetInView(targetBox)) {
+      return;
+    }
+    if (placement === 'top' || placement === 'bottom') {
+      positionBox.top = this.adjustForVerticalOverflow(positionBox.top, elementBox.height, targetBox.height);
+    }
+    else if (placement === 'left' || placement === 'right') {
+      positionBox.left = this.adjustForHorizontalOverflow(positionBox.left, elementBox.width, targetBox.width);
+    }
+    positionBox.top = this.keepVerticallyInView(positionBox.top, elementBox.height);
+    positionBox.left = this.keepHorizontallyInView(positionBox.left, elementBox.width);
+  }
+  /**
+   * Nudges `top` so the element stays within the viewport vertically.
+   * Only corrects when the overflow is less than `targetHeight` to keep the element
+   * visually anchored to its target; larger overflows are handled by `keepVerticallyInView`.
+   *
+   * @param {number} top - The calculated top position.
+   * @param {number} elementHeight - Height of the positioned element.
+   * @param {number} targetHeight - Height of the target, used as the max correctable overflow.
+   * @returns {number} The adjusted top position.
+   */
+  adjustForVerticalOverflow(top, elementHeight, targetHeight) {
+    // Pixels the element bleeds past the bottom of the viewport (positive = overflow).
+    const overflowBottom = top + elementHeight - window.innerHeight;
+    // Pixels the element bleeds past the top of the viewport (positive = overflow).
+    const overflowTop = -top;
+    // Only nudge when overflow is smaller than targetHeight; larger overflows are left to
+    // keepVerticallyInView to hard-clamp, since nudging that far would detach from the target.
+    if (overflowBottom > 0 && overflowBottom < targetHeight) {
+      return top - overflowBottom; // shift up until bottom edge is flush with viewport bottom
+    }
+    if (overflowTop > 0 && overflowTop < targetHeight) {
+      return top + overflowTop; // shift down until top edge is flush with viewport top
+    }
+    return top;
+  }
+  /**
+   * Nudges `left` so the element stays within the viewport horizontally.
+   * Only corrects when the overflow is less than `targetWidth` to keep the element
+   * visually anchored to its target; larger overflows are handled by `keepHorizontallyInView`.
+   *
+   * @param {number} left - The calculated left position.
+   * @param {number} elementWidth - Width of the positioned element.
+   * @param {number} targetWidth - Width of the target, used as the max correctable overflow.
+   * @returns {number} The adjusted left position.
+   */
+  adjustForHorizontalOverflow(left, elementWidth, targetWidth) {
+    // Pixels the element bleeds past the right edge of the viewport (positive = overflow).
+    const overflowRight = left + elementWidth - window.innerWidth;
+    // Pixels the element bleeds past the left edge of the viewport (positive = overflow).
+    const overflowLeft = -left;
+    // Only nudge when overflow is smaller than targetWidth; larger overflows are left to
+    // keepHorizontallyInView to hard-clamp, since nudging that far would detach from the target.
+    if (overflowRight > 0 && overflowRight < targetWidth) {
+      return left - overflowRight; // shift left until right edge is flush with viewport right
+    }
+    if (overflowLeft > 0 && overflowLeft < targetWidth) {
+      return left + overflowLeft; // shift right until left edge is flush with viewport left
+    }
+    return left;
+  }
   /**
    * It returns the translocation of the element relative to the target element
    *
@@ -564,7 +678,7 @@ class BasePositionCalculationStrategy extends VegaSlimmer {
    * @param {ElementBoundBox} targetBox - The box of the element that the element to be positioned is aligned to.
    * @param {PlacementType} placement - The placement of the element relative to the target.
    * @param {PositionAlignmentType[]} alignments - An array of alignments to try.
-   * @returns {PositionAlignmentType} the alignment that is suitable for the element.
+   * @returns {Nullable<PositionAlignmentType>} the alignment that is suitable for the element.
    */
   getSuitableAlignment(containerBox, elementBox, targetBox, placement, alignments) {
     const defaultAlignment = alignments[0];
@@ -577,7 +691,7 @@ class BasePositionCalculationStrategy extends VegaSlimmer {
                 No enough space found for placing element and we will keep using the defined alignment:
                 ${defaultAlignment}
             `);
-      return defaultAlignment;
+      return null;
     }
   }
   /**
@@ -826,9 +940,17 @@ class ScreenPositionCalculationStrategy extends BasePositionCalculationStrategy
    */
   getPosition(usePreviousPlacement) {
     const stayPlacement = usePreviousPlacement ? this.usePreviousPlacement : false;
-    const positionBox = stayPlacement
-      ? this.getPositionBox([this.previousPositionBox.placement], [this.previousPositionBox.alignment])
-      : this.getPositionBox();
+    let positionBox;
+    if (stayPlacement) {
+      positionBox = this.getPositionBox([this.previousPositionBox.placement].filter(isNonNullable), [this.previousPositionBox.alignment].filter(isNonNullable));
+      if (!FeatureFlag.isEnabled('VEGA_ELEMENT_APPENDER.AUTO_PLACEMENT')) {
+        positionBox.placement = this.previousPositionBox.placement;
+        positionBox.alignment = this.previousPositionBox.alignment;
+      }
+    }
+    else {
+      positionBox = this.getPositionBox();
+    }
     this.previousPositionBox = positionBox;
     return positionBox;
   }
@@ -887,7 +1009,7 @@ class ScreenPositionCalculationStrategy extends BasePositionCalculationStrategy
    * @param {ElementBoundBox} elementBox - The box of the element to place.
    * @param {ElementBoundBox} targetBox - The box of the target element.
    * @param {PlacementType[]} placements - Ordered list of placements to try.
-   * @returns {PlacementType} The chosen placement.
+   * @returns {Nullable<PlacementType>} The chosen placement.
    */
   getSuitablePlacement(containerBox, elementBox, targetBox, placements) {
     const alignments = this.getAlignments();
@@ -963,10 +1085,20 @@ class PositionCalculationController extends VegaSlimmer {
     }
     appendableElement.style.left = `${positionBox.left}px`;
     appendableElement.style.top = `${positionBox.top}px`;
-    appendableElement.classList.remove('vega-placement-left', 'vega-placement-right', 'vega-placement-top', 'vega-placement-bottom');
-    appendableElement.classList.remove('vega-alignment-start', 'vega-alignment-center', 'vega-alignment-end');
-    appendableElement.classList.add(`vega-placement-${positionBox.placement}`);
-    appendableElement.classList.add(`vega-alignment-${positionBox.alignment}`);
+    appendableElement.classList.remove('vega-placement-left', 'vega-placement-right', 'vega-placement-top', 'vega-placement-bottom', 'vega-no-suitable-placement');
+    appendableElement.classList.remove('vega-alignment-start', 'vega-alignment-center', 'vega-alignment-end', 'vega-no-suitable-alignment');
+    if (positionBox.placement) {
+      appendableElement.classList.add(`vega-placement-${positionBox.placement}`);
+    }
+    else {
+      appendableElement.classList.add(`vega-no-suitable-placement`);
+    }
+    if (positionBox.alignment) {
+      appendableElement.classList.add(`vega-alignment-${positionBox.alignment}`);
+    }
+    else {
+      appendableElement.classList.add(`vega-no-suitable-alignment`);
+    }
   }
   /**
    * It sets the width of the appendable element to the width of the target element if the
@@ -1704,6 +1836,7 @@ class ElementAppenderSlimmer extends VegaSlimmer {
   show() {
     this.elementAppender && this.elementAppender.show();
     this[this.isDropdownShowName] = true;
+    this.setAriaOwns();
   }
   hide() {
     this.elementAppender && this.elementAppender.hide();
@@ -1713,6 +1846,7 @@ class ElementAppenderSlimmer extends VegaSlimmer {
     });
   }
   destroy() {
+    this.removeAriaOwns();
     this.destroyElementAppender();
     this[this.isDropdownShowName] = false;
   }
@@ -1795,6 +1929,31 @@ class ElementAppenderSlimmer extends VegaSlimmer {
       return new NoneTriggerStrategy();
     }
   }
+  /**
+   * Sets `ariaOwnsElements` on the target element to reference the appendable element directly.
+   * Uses the Element Reflection API which works across shadow DOM boundaries by using
+   * direct element references instead of IDREF strings.
+   * This ensures screen readers (e.g. VoiceOver) can navigate to the portal-appended
+   * content immediately after the trigger, rather than at the end of the document.
+   */
+  setAriaOwns() {
+    if (this.showConfig) {
+      const target = this.showConfig.target;
+      const appendableElement = this.showConfig.appendableElement;
+      if (target && appendableElement) {
+        target.ariaOwnsElements = [appendableElement];
+      }
+    }
+  }
+  /**
+   * Removes `ariaOwnsElements` from the target element when the popup is hidden or destroyed.
+   */
+  removeAriaOwns() {
+    var _a;
+    if ((_a = this.showConfig) === null || _a === void 0 ? void 0 : _a.target) {
+      this.showConfig.target.ariaOwnsElements = [];
+    }
+  }
 }
 ElementAppenderSlimmer.DELAY_HIDE_TIME = 100;
 __decorate([

package/dist/esm/{form-field-controller-slimmer-5817d14d.js → form-field-controller-slimmer-e1a5a884.js}

@@ -8,7 +8,7 @@ import { a as isAsyncFunction, g as generateUUID } from './misc-9fdbcfbb.js';
 import { c as createDynamicSlimmer } from './dynamic-slimmer-90b8af32.js';
 import { d as domNodeSubjectFactory, D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-82f346e3.js';
 import { e as VegaInternalFieldErrorStateChange, c as VegaInternalFormSubmit, f as VegaInternalValid } from './vega-internal-event-id-799d012e.js';
-import { V as VegaInternalTranslation } from './internal-translation-controller-911515f9.js';
+import { V as VegaInternalTranslation } from './internal-translation-controller-113a6288.js';
 import { h as htmlSanitizer, l as labelSanitizeStrategy } from './index-3b327f29.js';
 import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-d6af0d86.js';
 import { I as InternalFormFieldValidationRule } from './internal-form-field-validation-rule.abstract-f5b6bdbf.js';

package/dist/esm/{image-annotation-action-6701b4c9.js → image-annotation-action-54936eaa.js}

@@ -1,11 +1,11 @@
 import { h } from './index-090d31ca.js';
 import { V as VegaInternalIconManager } from './internal-icon-manager-bd80b3bb.js';
 import { c as MapToComponentField, V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
-import { A as ActionHandleStrategyRegistry, O as RTE_TEXT_COLORS, b as RTETextNode, $ as TextColorAnnotationAction, y as NodeAnnotationTypeEnum, F as AnnotationAction } from './code-block-b6247a45.js';
+import { A as ActionHandleStrategyRegistry, O as RTE_TEXT_COLORS, b as RTETextNode, $ as TextColorAnnotationAction, y as NodeAnnotationTypeEnum, F as AnnotationAction } from './code-block-2408a812.js';
 import { D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-82f346e3.js';
 import { a as VegaClick, T as VegaPopoverShow, U as VegaPopoverHide, f as VegaChange } from './vega-event-id-38aa77a0.js';
 import { a as VegaDarkModeStyleController } from './dark-mode-style-controller-82e5c1c6.js';
-import { g as ImageAnnotation } from './dto-renderer-manager-6fd22ab7.js';
+import { g as ImageAnnotation } from './dto-renderer-manager-d413de1e.js';
 
 const text = {
   icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor" d="M64 96v32c0 17.7-14.3 32-32 32s-32-14.3-32-32V80C0 53.5 21.5 32 48 32H224 400c26.5 0 48 21.5 48 48v48c0 17.7-14.3 32-32 32s-32-14.3-32-32V96H256l0 320h48c17.7 0 32 14.3 32 32s-14.3 32-32 32H144c-17.7 0-32-14.3-32-32s14.3-32 32-32h48l0-320H64z"/></svg>`,

package/dist/esm/index.js

@@ -1,35 +1,35 @@
 export { g as getCurrentBreakpoint } from './breakpoints-56e5407b.js';
 export { L as LogUtility, s as setVegaLogLevel } from './global-slimmer-registry-17c4efd4.js';
-export { d as formatAndValidBackgroundColor, e as formatAndValidBorderColor, g as formatAndValidBorderRadius, c as formatAndValidBreakpointSize, a as formatAndValidGap, h as formatAndValidPadding, f as formatAndValidResponsiveToken, b as formatAndValidShadow, i as formatAndValidTextColor } from './design-token-5bc034e1.js';
+export { d as formatAndValidBackgroundColor, e as formatAndValidBorderColor, g as formatAndValidBorderRadius, c as formatAndValidBreakpointSize, a as formatAndValidGap, h as formatAndValidPadding, f as formatAndValidResponsiveToken, b as formatAndValidShadow, i as formatAndValidTextColor } from './design-token-7dec1eab.js';
 export { c as camelToDashCase } from './string-a953eafc.js';
-export { d as BackgroundColorMap, a as BackgroundColors, e as BorderColorMap, b as BorderColors, B as BorderRadius, C as Colors, F as FillBackgroundColors, g as ShadowMap, f as Shadows, h as Spacing, S as StrokeBackgroundColors, c as TextColorMap, T as TextColors } from './type-guard-f50e34d6.js';
+export { d as BackgroundColorMap, a as BackgroundColors, e as BorderColorMap, b as BorderColors, B as BorderRadius, C as Colors, F as FillBackgroundColors, g as ShadowMap, f as Shadows, h as Spacing, S as StrokeBackgroundColors, c as TextColorMap, T as TextColors } from './type-guard-af324dcd.js';
 export { B as Breakpoints } from './breakpoints-d9faf11c.js';
 export { I as Icons, g as getIconFromToken } from './icons-8627925e.js';
 export { b as Typography, a as TypographyKeys, T as TypographyUrls } from './typography-396de03f.js';
 export { d as BoxDisplay, e as BreakpointKeys, C as CssStates, F as FlexDirections } from './ui-28fd4193.js';
 export { F as FrameworkEnum, v as VegaEnvManager } from './vega-env-manager-8f8dc473.js';
-export { A as ActionHandlerInterceptor, I as InsertNodeToNearestRootAction, o as RTELanguageToolbarButtonRenderer, m as RTETokenNode, n as RTETokenNodeRenderer, R as RTETokenToolbarButtonRenderer, c as VegaEventManager, V as VegaLoader, a as VegaNotify, j as VegaRTEExtension, k as VegaRTEExtensionRenderer, i as VegaRTEFunctionExtension, h as VegaRTELanguageExtension, g as VegaRTETokenExtension, l as VegaRTEToolbarButtonRenderer, e as VegaSkeletonLoader, b as VegaThemeManager, f as VegaTranslation, d as VegaZIndexManager, w as waitForVega } from './token-extension-73e4460a.js';
+export { A as ActionHandlerInterceptor, I as InsertNodeToNearestRootAction, o as RTELanguageToolbarButtonRenderer, m as RTETokenNode, n as RTETokenNodeRenderer, R as RTETokenToolbarButtonRenderer, c as VegaEventManager, V as VegaLoader, a as VegaNotify, j as VegaRTEExtension, k as VegaRTEExtensionRenderer, i as VegaRTEFunctionExtension, h as VegaRTELanguageExtension, g as VegaRTETokenExtension, l as VegaRTEToolbarButtonRenderer, e as VegaSkeletonLoader, b as VegaThemeManager, f as VegaTranslation, d as VegaZIndexManager, w as waitForVega } from './token-extension-25df8dbb.js';
 export { F as FeatureFlag } from './feature-flag-controller-30f7b625.js';
 export { V as VegaDialog } from './vega-dialog-controller-bbb2fc52.js';
 export { B as VegaJQueryDelegatedEventStrategy } from './internal-vega-event-manager-32a3d848.js';
 export { V as VegaIconManager } from './icon-manager-539d7cf7.js';
-export { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-22ce81db.js';
+export { V as ValidCreditCardNumberRule } from './valid-credit-card-number-rule-099dba7d.js';
 import './ui-ee31416b.js';
-export { s as VegaTranslationResourceEN } from './internal-translation-controller-911515f9.js';
+export { s as VegaTranslationResourceEN } from './internal-translation-controller-113a6288.js';
 export { s as setVegaNonce } from './vega-nonce-manager-497e5eb5.js';
-export { f as ActionHandleStrategy, g as AppendChildrenAction, Q as CodeLanguage, C as CustomAttributeAnnotation, w as CustomClassAnnotation, v as CustomStyleAnnotation, I as InsertChildrenAfterAction, i as InsertChildrenBeforeAction, M as ModifyContentAction, k as ModifyContentActionType, e as RTEAnnotationStyle, c as RTEBlock, z as RTEDecoratorNode, h as RTENode, d as RTETextBlock, b as RTETextNode, r as RemoveChildrenAction, V as VegaRTEPresetToolbarItems } from './code-block-b6247a45.js';
-export { B as BlockToRTEBlockStrategyAbstract, b as ElementToDTOStrategy, I as InsertNewParagraphAction, c as RTEImageBlock, f as RTEImageNode, e as RTEListBlock, d as RTEListItemBlock, U as UpdateCursorPositionAction, V as VegaRTEContent, h as htmlElementToAnnotationGenerator } from './dto-renderer-manager-6fd22ab7.js';
-export { G as GridColumns, a as GridRows } from './responsive-format-facade-aa705823.js';
+export { f as ActionHandleStrategy, g as AppendChildrenAction, Q as CodeLanguage, C as CustomAttributeAnnotation, w as CustomClassAnnotation, v as CustomStyleAnnotation, I as InsertChildrenAfterAction, i as InsertChildrenBeforeAction, M as ModifyContentAction, k as ModifyContentActionType, e as RTEAnnotationStyle, c as RTEBlock, z as RTEDecoratorNode, h as RTENode, d as RTETextBlock, b as RTETextNode, r as RemoveChildrenAction, V as VegaRTEPresetToolbarItems } from './code-block-2408a812.js';
+export { B as BlockToRTEBlockStrategyAbstract, b as ElementToDTOStrategy, I as InsertNewParagraphAction, c as RTEImageBlock, f as RTEImageNode, e as RTEListBlock, d as RTEListItemBlock, U as UpdateCursorPositionAction, V as VegaRTEContent, h as htmlElementToAnnotationGenerator } from './dto-renderer-manager-d413de1e.js';
+export { G as GridColumns, a as GridRows } from './responsive-format-facade-2a36c54a.js';
 export { C as CheckBoxRequiredRule } from './check-box-required-rule-cb0aa339.js';
-export { D as DateRequiredRule } from './date-required-rule-e771e7d9.js';
+export { D as DateRequiredRule } from './date-required-rule-09d5aa16.js';
 export { I as InputPhoneNumberRequiredRule } from './input-phone-number-required-rule-be6a5572.js';
 export { I as InputRangeRequiredRule } from './input-range-required-rule-3ad74776.js';
 export { R as RequiredFieldRule } from './required-field-rule-ab4bdc47.js';
-export { R as RichTextEditorRequiredRule } from './rich-text-editor-required-rule-a238b862.js';
-export { T as TimeRangeRequiredRule, a as TimeRequiredRule } from './time-required-rule-e4138a76.js';
+export { R as RichTextEditorRequiredRule } from './rich-text-editor-required-rule-b09039da.js';
+export { T as TimeRangeRequiredRule, a as TimeRequiredRule } from './time-required-rule-c7cfb257.js';
 export { T as ToggleSwitchRequiredRule } from './toggle-switch-required-rule-b3cf4302.js';
 export { F as FileUploaderRequiredRule } from './file-uploader-required-rule-ad886d01.js';
-export { R as RTERange } from './range-663f44dc.js';
+export { R as RTERange } from './range-a5d78e69.js';
 import './misc-9fdbcfbb.js';
 import './create-public-api-runtime-metrics-slimmer-aaadaa08.js';
 import './dynamic-slimmer-90b8af32.js';

package/dist/esm/{inject-keyboard-manager-78730062.js → inject-keyboard-manager-9339bba8.js}

@@ -1,4 +1,4 @@
-import { K as KeyboardManager } from './keyboard-manager-38934f94.js';
+import { K as KeyboardManager } from './keyboard-manager-f9bfa678.js';
 
 /**
  * It takes a function that returns an array of keyboard event listeners, and returns a decorator

package/dist/esm/{internal-translation-controller-911515f9.js → internal-translation-controller-113a6288.js}

@@ -35,6 +35,8 @@ const staticTranslations = {
   'Upload': 'Upload',
   'Clear': 'Clear',
   'Today': 'Today',
+  'Previous month': 'Previous month',
+  'Next month': 'Next month',
   'Day': 'Day',
   'Week': 'Week',
   'Month': 'Month',
@@ -52,6 +54,13 @@ const staticTranslations = {
   'Thu-short': 'T',
   'Fri-short': 'F',
   'Sat-short': 'S',
+  'Sun-full': 'Sunday',
+  'Mon-full': 'Monday',
+  'Tue-full': 'Tuesday',
+  'Wed-full': 'Wednesday',
+  'Thu-full': 'Thursday',
+  'Fri-full': 'Friday',
+  'Sat-full': 'Saturday',
   'January': 'January',
   'February': 'February',
   'March': 'March',
@@ -107,6 +116,10 @@ const staticTranslations = {
   'Less Indent': 'Less Indent',
   'Link': 'Link',
   'Image': 'Image',
+  'Upload from computer': 'Upload from computer',
+  'Insert via URL': 'Insert via URL',
+  'Image via URL': 'Image via URL',
+  'Insert': 'Insert',
   'Clear Style': 'Clear Style',
   'URL': 'URL',
   'Text': 'Text',
@@ -149,6 +162,8 @@ const staticTranslations = {
   'Saturday': 'Saturday',
   'am': 'am',
   'pm': 'pm',
+  'date picker': 'Date Picker',
+  'Selected result': 'Selected result',
 };
 
 /**

package/dist/esm/{keyboard-manager-38934f94.js → keyboard-manager-f9bfa678.js}

@@ -1,5 +1,5 @@
 import { b as isParent, e as getDeepActiveElementInShadow } from './ui-ee31416b.js';
-import { i as isNonNullable } from './type-guard-f50e34d6.js';
+import { i as isNonNullable } from './type-guard-af324dcd.js';
 
 /**
  * It listens to the keyup event on the window and calls the appropriate method on the registered elements

package/dist/esm/{keyboard-manager-slimmer-9984d922.js → keyboard-manager-slimmer-c8898843.js}

@@ -1,5 +1,5 @@
 import { M as MapToComponentMethod, V as VegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
-import { K as KeyboardManager } from './keyboard-manager-38934f94.js';
+import { K as KeyboardManager } from './keyboard-manager-f9bfa678.js';
 
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;