@globalpayments/vega 2.57.1 → 2.59.0

package/dist/collection/components/vega-selection-tile/vega-selection-tile-group/vega-selection-tile-group.js

@@ -47,6 +47,7 @@ export class VegaSelectionTileGroup {
     this.selectTypeNotifySlimmer = createSubStateNotifySlimmer(VegaSelectionTileGroup, 'selectType', 'watchSelectType');
     this.disabledNotifySlimmer = createSubStateNotifySlimmer(VegaSelectionTileGroup, 'disabled', 'watchDisabled');
     this.valueNotifySlimmer = createSubStateNotifySlimmer(VegaSelectionTileGroup, 'value', 'watchValue');
+    this.distributeEvenlyNotifySlimmer = createSubStateNotifySlimmer(VegaSelectionTileGroup, 'distributeEvenly', 'watchDistributeEvenly');
     this.vegaComponentUsageRuntimeMetricsSlimmer = new VegaComponentUsageRuntimeMetricsSlimmer();
     /**
      * Specifies the label or title for the selection tile group.
@@ -56,6 +57,12 @@ export class VegaSelectionTileGroup {
      * @vegaVersion 2.7.0
      */
     this.label = '';
+    /**
+     * Distribute vega-selection-tile components evenly to always cover the entire available width of the vega-selection-tile-group
+     *
+     * @vegaVersion 2.58.0
+     */
+    this.distributeEvenly = false;
     /**
      * Determines the selection method for the tile group. Options are:
      *
@@ -96,6 +103,9 @@ export class VegaSelectionTileGroup {
     /* eslint-disable-next-line @stencil/strict-mutable */
     this.isValid = null;
   }
+  watchDistributeEvenly() {
+    methodPlaceholder();
+  }
   watchSelectType() {
     methodPlaceholder();
   }
@@ -161,6 +171,27 @@ export class VegaSelectionTileGroup {
       "attribute": "hint",
       "reflect": false
     },
+    "distributeEvenly": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [{
+            "name": "vegaVersion",
+            "text": "2.58.0"
+          }],
+        "text": "Distribute vega-selection-tile components evenly to always cover the entire available width of the vega-selection-tile-group"
+      },
+      "attribute": "distribute-evenly",
+      "reflect": false,
+      "defaultValue": "false"
+    },
     "selectType": {
       "type": "string",
       "mutable": false,
@@ -352,6 +383,9 @@ export class VegaSelectionTileGroup {
     }]; }
   static get elementRef() { return "host"; }
   static get watchers() { return [{
+      "propName": "distributeEvenly",
+      "methodName": "watchDistributeEvenly"
+    }, {
       "propName": "selectType",
       "methodName": "watchSelectType"
     }, {
@@ -398,6 +432,9 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], VegaSelectionTileGroup.prototype, "valueNotifySlimmer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaSelectionTileGroup.prototype, "distributeEvenlyNotifySlimmer", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], VegaSelectionTileGroup.prototype, "vegaComponentUsageRuntimeMetricsSlimmer", void 0);

package/dist/collection/components/vega-selection-tile/vega-selection-tile.css

@@ -3,6 +3,18 @@
  * Deprecated. Not for use in new websites.
  * https://developer.mozilla.org/en-US/docs/Web/CSS/word-break#break-word
  */
+:host::not(.distribute-evenly) {
+  display: block;
+}
+
+:host(.distribute-evenly) {
+  display: flex;
+  width: 100%;
+}
+:host(.distribute-evenly) .selection-tile {
+  flex: 1;
+}
+
 :host {
   display: block;
 }

package/dist/collection/components/vega-selection-tile/vega-selection-tile.js

@@ -40,6 +40,10 @@ export class VegaSelectionTile {
      * Indicates whether the parent selection tile group shows error message.
      */
     this.showError = false;
+    /**
+     * Distribute vega-selection-tile components evenly to always cover the entire available width of the parent
+     */
+    this.distributeEvenly = false;
     /**
      * Specifies the text content of the title displayed
      *    within the selection tile.
@@ -68,7 +72,7 @@ export class VegaSelectionTile {
     this.selectType = 'radio';
   }
   render() {
-    return sanitizeVegaComponent(h(Host, null, this.renderer.render()), this.host);
+    return sanitizeVegaComponent(h(Host, { class: { 'distribute-evenly': this.distributeEvenly } }, this.renderer.render()), this.host);
   }
   static get is() { return "vega-selection-tile"; }
   static get encapsulation() { return "shadow"; }
@@ -224,7 +228,8 @@ export class VegaSelectionTile {
     }
   }; }
   static get states() { return {
-    "showError": {}
+    "showError": {},
+    "distributeEvenly": {}
   }; }
   static get events() { return [{
       "method": "vegaChange",

package/dist/collection/constants/ui.js

@@ -83,6 +83,7 @@ export const VegaNativeEventName = [
   'labelButtonClick',
   'imageInserted',
   'reset',
+  'eventPreviewShow',
 ];
 // eslint-disable-next-line @typescript-eslint/typedef
 export const CssStates = ['default', 'hover', 'active', 'focus-visible'];

package/dist/collection/helpers/calendar/calendar-date.js

@@ -1,3 +1,4 @@
+import { VegaInternalTranslation } from '../translation';
 /**
  * Calendar date class
  */
@@ -111,4 +112,15 @@ export class CalendarDate {
     const { year, month, date } = calendarDate;
     return this._year === year && this._month === month && this._date === date;
   }
+  /**
+   * Get month name.
+   *
+   * @param {boolean} isShortName - Whether to get the short name or long name of the month
+   * @returns {string} The name of the month
+   */
+  getMonthName(isShortName = false) {
+    return VegaInternalTranslation.t(this.toDate().toLocaleDateString('en-US', {
+      month: isShortName ? 'short' : 'long',
+    }));
+  }
 }

package/dist/collection/helpers/calendar/calendar-event.js

@@ -1,6 +1,8 @@
 import calendarEventRepeatPatternFactory from '../../components/vega-calendar/slimmers/common/helpers/repeat-pattern/calendar-event-repeat-pattern-factory';
 import { generateUUID } from '../../utils/misc';
+import { VegaInternalTranslation } from '../translation';
 import { CalendarDate } from './calendar-date';
+import { formatDisplayTime, WeekdayLongNames } from './utils';
 const CalendarDateFormatReg = /^\d{1,2}\/\d{1,2}\/\d{4}/;
 const CalendarTimeFormatReg = /^\d{1,2}:\d{1,2}/;
 /** The `CalendarEvent` class in TypeScript represents a calendar event with methods to validate required fields, initialize dates and times, and determine if it is a group event. */
@@ -170,6 +172,28 @@ export class CalendarEvent {
     const currentDate = date.toDate();
     return startCalendarDate.toDate() <= currentDate && endCalendarDate.toDate() > currentDate;
   }
+  /**
+   * Generate repeat display string.
+   *
+   * @returns {string} repeat display string
+   */
+  generateRepeatString() {
+    var _a;
+    return ((_a = this.repeatPattern) === null || _a === void 0 ? void 0 : _a.generateRepeatString()) || '';
+  }
+  /**
+   * Generate date display string.
+   *
+   * @param {CalendarDate} viewDate - The `date` to display
+   * @param {TimeFormat} timeFormat - The `timeFormat` to use
+   * @returns {string} repeat display string
+   */
+  generateDateTimeString(viewDate, timeFormat) {
+    const weekDay = VegaInternalTranslation.t(Object.values(WeekdayLongNames)[viewDate.toDate().getDay()]);
+    const startTime = formatDisplayTime(timeFormat, this.startTime);
+    const endTime = formatDisplayTime(timeFormat, this.endTime);
+    return `${weekDay}, ${viewDate.date} ${viewDate.getMonthName(true)} ${viewDate.year} ${startTime} - ${endTime}`;
+  }
   /**
    * Get the number of minutes the event lasted
    *

package/dist/collection/helpers/calendar/calendar-period/month-period.js

@@ -1,11 +1,12 @@
 import { CalendarPeriod } from './calendar-period.abstract';
 import { CalendarDate } from '../calendar-date';
+import { getWeekdays } from '../utils';
 /**
  * Period of month
  */
 export class MonthPeriod extends CalendarPeriod {
   constructor(current, showWeekends) {
-    super(MonthPeriod.DISPLAY_DATE_COUNT, MonthPeriod.getMonthFirstDay(current));
+    super(MonthPeriod.DISPLAY_DATE_COUNT, current);
     this._type = 'month';
     this._showWeekends = true;
     this._showWeekends = showWeekends === false ? false : true;
@@ -24,6 +25,19 @@ export class MonthPeriod extends CalendarPeriod {
     const date = calendarDate || CalendarDate.from(new Date());
     return new CalendarDate(date.year, date.month, 1);
   }
+  /**
+   * Calculate the period start date and end date.
+   *
+   * @param {CalendarDate} date - The date to calculate the period from.
+   */
+  calculatePeriod(date) {
+    const firstDay = MonthPeriod.getMonthFirstDay(date);
+    const cursor = firstDay.toDate();
+    cursor.setDate(cursor.getDate() - getWeekdays().indexOf(cursor.getDay()));
+    this._startDate = CalendarDate.from(cursor);
+    cursor.setDate(cursor.getDate() + this.count - 1);
+    this._endDate = CalendarDate.from(cursor);
+  }
   /**
    * @inheritDoc
    */

package/dist/collection/helpers/calendar/calendar-period/week-period.js

@@ -1,5 +1,4 @@
 import { CalendarPeriod } from './calendar-period.abstract';
-import { getWeekdays } from '../utils';
 import { CalendarDate } from '../calendar-date';
 /**
  * Period of the week
@@ -15,17 +14,17 @@ export class WeekPeriod extends CalendarPeriod {
    * @inheritDoc
    */
   next() {
-    const nextWeekStartDate = this.current.toDate();
-    nextWeekStartDate.setDate(nextWeekStartDate.getDate() - getWeekdays().indexOf(nextWeekStartDate.getDay()) + 7);
-    return this.createBy(CalendarDate.from(nextWeekStartDate));
+    const currentDate = this.current.toDate();
+    currentDate.setDate(currentDate.getDate() + 7);
+    return this.createBy(CalendarDate.from(currentDate));
   }
   /**
    * @inheritDoc
    */
   previous() {
-    const previousWeekStartDate = this.current.toDate();
-    previousWeekStartDate.setDate(previousWeekStartDate.getDate() - getWeekdays().indexOf(previousWeekStartDate.getDay()) - 7);
-    return this.createBy(CalendarDate.from(previousWeekStartDate));
+    const currentDate = this.current.toDate();
+    currentDate.setDate(currentDate.getDate() - 7);
+    return this.createBy(CalendarDate.from(currentDate));
   }
   /**
    * @inheritDoc

package/dist/collection/helpers/calendar/test/calendar-date.test.js

@@ -68,4 +68,8 @@ describe('calendar-date', () => {
       isPreviousMonth: false,
     });
   });
+  it('should return as expected when call getMonthName', () => {
+    expect(new CalendarDate(2024, 2, 10).getMonthName()).toBe('February');
+    expect(new CalendarDate(2024, 2, 10).getMonthName(true)).toBe('Feb');
+  });
 });

package/dist/collection/helpers/calendar/test/calendar-event.test.js

@@ -130,4 +130,61 @@ describe('calendar-event', () => {
     expect(copyEvent2.endDate.getDate()).toEqual(17);
     expect(copyEvent2.eventKey).toEqual('test');
   });
+  it('should return proper when call generateDateTimeString', () => {
+    const calendarEvent = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startTime: '10:00', endTime: '11:00' }));
+    expect(calendarEvent.generateDateTimeString(new CalendarDate(2024, 6, 14), '12-hour')).toBe('Friday, 14 Jun 2024 10:00 am - 11:00 am');
+    expect(calendarEvent.generateDateTimeString(new CalendarDate(2024, 6, 14), '24-hour')).toBe('Friday, 14 Jun 2024 10:00 - 11:00');
+  });
+  it('should return proper when call generateRepeatString', () => {
+    const calendarEvent1 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'daily',
+        interval: 2,
+      } }));
+    expect(calendarEvent1.generateRepeatString()).toBe('Repeat every 2 days');
+    const calendarEvent2 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'daily',
+      } }));
+    expect(calendarEvent2.generateRepeatString()).toBe('Repeat daily');
+    const calendarEvent3 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'weekly',
+        interval: 2,
+        byWeekDay: ['Thu', 'Fri'],
+      } }));
+    expect(calendarEvent3.generateRepeatString()).toBe('Repeat every 2 weeks on Thursday, Friday');
+    const calendarEvent4 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'weekly',
+        byWeekDay: ['Thu', 'Fri'],
+      } }));
+    expect(calendarEvent4.generateRepeatString()).toBe('Repeat weekly on Thursday, Friday');
+    const calendarEvent5 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', repeatOptions: {
+        frequency: 'monthly',
+        interval: 2,
+      } }));
+    expect(calendarEvent5.generateRepeatString()).toBe('Repeat every 2 months on day 14');
+    const calendarEvent6 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', repeatOptions: {
+        frequency: 'monthly',
+      } }));
+    expect(calendarEvent6.generateRepeatString()).toBe('Repeat monthly on day 14');
+    const calendarEvent7 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', repeatOptions: {
+        frequency: 'yearly',
+        interval: 2,
+      } }));
+    expect(calendarEvent7.generateRepeatString()).toBe('Repeat every 2 years on June 14');
+    const calendarEvent8 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { startDate: '06/14/2024', repeatOptions: {
+        frequency: 'yearly',
+      } }));
+    expect(calendarEvent8.generateRepeatString()).toBe('Repeat yearly on June 14');
+    const calendarEvent9 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'daily',
+        until: '06/20/2024',
+      } }));
+    expect(calendarEvent9.generateRepeatString()).toBe('Repeat daily until June 20, 2024');
+    const calendarEvent10 = new CalendarEvent(Object.assign(Object.assign({}, rawEvent), { repeatOptions: {
+        frequency: 'daily',
+        count: 20,
+      } }));
+    expect(calendarEvent10.generateRepeatString()).toBe('Repeat daily after 20 occurrences');
+    const calendarEvent11 = new CalendarEvent(Object.assign({}, rawEvent));
+    expect(calendarEvent11.generateRepeatString()).toBe('');
+  });
 });

package/dist/collection/helpers/calendar/test/calendar-period/month-period.test.js

@@ -12,7 +12,7 @@ describe('month-period', () => {
     const { current, count, startDate, endDate } = new MonthPeriod();
     expect({ current, count, startDate, endDate }).toEqual({
       count: 42,
-      current: new CalendarDate(2020, 4, 1),
+      current: new CalendarDate(2020, 4, 3),
       startDate: new CalendarDate(2020, 3, 29),
       endDate: new CalendarDate(2020, 5, 9),
     });
@@ -32,7 +32,7 @@ describe('month-period', () => {
     const { current, count, startDate, endDate } = monthPeriod.now();
     expect({ current, count, startDate, endDate }).toEqual({
       count: 42,
-      current: new CalendarDate(2020, 4, 1),
+      current: new CalendarDate(2020, 4, 3),
       startDate: new CalendarDate(2020, 3, 29),
       endDate: new CalendarDate(2020, 5, 9),
     });
@@ -42,7 +42,7 @@ describe('month-period', () => {
     const { current, count, startDate, endDate } = monthPeriod.next();
     expect({ current, count, startDate, endDate }).toEqual({
       count: 42,
-      current: new CalendarDate(2020, 5, 1),
+      current: new CalendarDate(2020, 5, 3),
       startDate: new CalendarDate(2020, 4, 26),
       endDate: new CalendarDate(2020, 6, 6),
     });
@@ -52,9 +52,17 @@ describe('month-period', () => {
     const { current, count, startDate, endDate } = monthPeriod.previous();
     expect({ current, count, startDate, endDate }).toEqual({
       count: 42,
-      current: new CalendarDate(2020, 3, 1),
+      current: new CalendarDate(2020, 3, 3),
       startDate: new CalendarDate(2020, 3, 1),
       endDate: new CalendarDate(2020, 4, 11),
     });
   });
+  it('should work when get month first day', () => {
+    const { year, month, date } = MonthPeriod.getMonthFirstDay();
+    expect({ year, month, date }).toEqual({
+      year: 2020,
+      month: 4,
+      date: 1,
+    });
+  });
 });

package/dist/collection/helpers/calendar/test/calendar-period/week-period.test.js

@@ -42,7 +42,7 @@ describe('week-period', () => {
     const { current, count, startDate, endDate } = weekPeriod.next();
     expect({ current, count, startDate, endDate }).toEqual({
       count: 7,
-      current: new CalendarDate(2020, 4, 5),
+      current: new CalendarDate(2020, 4, 10),
       startDate: new CalendarDate(2020, 4, 5),
       endDate: new CalendarDate(2020, 4, 11),
     });
@@ -52,7 +52,7 @@ describe('week-period', () => {
     const { current, count, startDate, endDate } = weekPeriod.previous();
     expect({ current, count, startDate, endDate }).toEqual({
       count: 7,
-      current: new CalendarDate(2020, 3, 22),
+      current: new CalendarDate(2020, 3, 27),
       startDate: new CalendarDate(2020, 3, 22),
       endDate: new CalendarDate(2020, 3, 28),
     });

package/dist/collection/helpers/calendar/utils.js

@@ -1,3 +1,4 @@
+import { VegaInternalTranslation } from '../translation';
 /**
  * Get a week days array
  *
@@ -8,3 +9,40 @@ export const getWeekdays = (firstWeekDay = 0) => {
   const weekdays = [0, 1, 2, 3, 4, 5, 6];
   return weekdays.concat(weekdays).slice(firstWeekDay, firstWeekDay + 7);
 };
+export var WeekdayLongNames;
+(function (WeekdayLongNames) {
+  WeekdayLongNames["sun"] = "Sunday";
+  WeekdayLongNames["mon"] = "Monday";
+  WeekdayLongNames["tue"] = "Tuesday";
+  WeekdayLongNames["wed"] = "Wednesday";
+  WeekdayLongNames["thu"] = "Thursday";
+  WeekdayLongNames["fri"] = "Friday";
+  WeekdayLongNames["sat"] = "Saturday";
+})(WeekdayLongNames || (WeekdayLongNames = {}));
+/**
+ * Format display time
+ *
+ * @param {TimeFormat} timeFormat - The time format (24-hour or 12-hour)
+ * @param {string} timeString - The time string to format
+ * @returns {string} - The formatted time string
+ */
+export const formatDisplayTime = (timeFormat, timeString) => {
+  const [hour, minutes] = timeString.split(':');
+  if (timeFormat === '24-hour') {
+    return `${hour.padStart(2, '0')}:${minutes.padStart(2, '0')}`;
+  }
+  else {
+    const hourNum = Number(hour);
+    const amPm = hourNum >= 12 ? 'pm' : 'am';
+    const minutesResult = minutes.padStart(2, '0');
+    if (hourNum > 12) {
+      return `${hourNum - 12}:${minutesResult} ${VegaInternalTranslation.t('pm')}`;
+    }
+    else if (hourNum === 0) {
+      return `12:${minutesResult} ${VegaInternalTranslation.t('am')}`;
+    }
+    else {
+      return `${hourNum}:${minutesResult} ${VegaInternalTranslation.t(amPm)}`;
+    }
+  }
+};

package/dist/collection/helpers/change-manager/subject/static-subject/static-subject-title.js

@@ -28,3 +28,4 @@ export const DARK_MODE_CHANGE = new StaticSubject('DARK_MODE_CHANGE');
 export const SHADOW_ROOT_ELEMENT_SCROLLING = new StaticSubject('SHADOW_ROOT_ELEMENT_SCROLLING');
 export const FLAG_ICON_LOADED = new StaticSubject('FLAG_ICON_LOADED');
 export const GP_BRAND_CHANGE = new StaticSubject('GP_BRAND_CHANGE');
+export const CALENDAR_EVENT_PREVIEW_POPOVER_HIDE = new StaticSubject('CALENDAR_EVENT_PREVIEW_POPOVER_HIDE');

package/dist/collection/helpers/code-format/code-formatter.js

@@ -0,0 +1,116 @@
+/**
+ * Class to format HTML code with proper indentation and style cleanup.
+ */
+class CodeFormatter {
+  constructor() {
+    /**
+     * Formats a given HTML source string by applying indentation and cleaning up styles.
+     *
+     * @param {string} source - The HTML source string to format.
+     * @param {CodeFormatOptions} options - Formatting options.
+     * @returns {string} The formatted HTML string.
+     */
+    this.format = (source, options = {}) => {
+      const { tabWidth = 4, useTabs = true } = options;
+      const indentUnit = useTabs ? '\t' : ' ';
+      const INDENT = indentUnit.repeat(tabWidth);
+      const tagRegex = /(<\/?[^>]+>)/g;
+      // Split source into tokens using tag boundaries while filtering out empty strings
+      const tokens = source.split(tagRegex).filter((t) => t.length > 0);
+      let indentLevel = 0;
+      let output = '';
+      for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i];
+        // Decrease indentation for closing tags
+        if (token.startsWith('</')) {
+          indentLevel = Math.max(0, indentLevel - 1);
+        }
+        const indent = INDENT.repeat(indentLevel);
+        if (token.startsWith('<')) {
+          // Clean and normalize inline style attributes
+          token = token.replace(/style\s*=\s*"([^"]*)"/g, (_, styleContent) => {
+            return `style="${this.formatStyle(styleContent)}"`;
+          });
+          const tagName = CodeFormatter.getTagName(token);
+          const isInline = CodeFormatter.INLINE_TAGS.has(tagName);
+          // Inline tag grouping: e.g., <strong>Text</strong> stays on one line
+          if (isInline && i + 2 < tokens.length && tokens[i + 2] === `</${tagName}>`) {
+            // Group consecutive inline tags
+            let inlineGroup = `${token}${tokens[i + 1]}${tokens[i + 2]}`;
+            i += 2;
+            // Keep merging consecutive inline tag pairs
+            while (i + 2 < tokens.length &&
+              tokens[i + 1].startsWith('<') &&
+              CodeFormatter.INLINE_TAGS.has(CodeFormatter.getTagName(tokens[i + 1])) &&
+              tokens[i + 3] === `</${CodeFormatter.getTagName(tokens[i + 1])}>`) {
+              inlineGroup += `${tokens[i + 1]}${tokens[i + 2]}${tokens[i + 3]}`;
+              i += 3;
+            }
+            output += `${indent}${inlineGroup}\n`;
+          }
+          else {
+            output += `${indent}${token}\n`;
+            // Increase indentation for non-void opening tags
+            if (!token.startsWith('</') &&
+              !token.endsWith('/>') &&
+              !/^<br|^<img|^<meta|^<input|^<hr/i.test(token)) {
+              indentLevel++;
+            }
+          }
+        }
+        else {
+          // Add plain text content with current indentation
+          const text = token;
+          if (text.length > 0) {
+            output += `${INDENT.repeat(indentLevel)}${text}\n`;
+          }
+        }
+      }
+      return output.trim();
+    };
+  }
+  /**
+   * Extracts the tag name from an HTML tag string.
+   *
+   * @param {string} tag - A raw HTML tag string
+   * @returns {string} The lowercase tag name, or an empty string if no match is found.
+   */
+  static getTagName(tag) {
+    var _a;
+    const match = tag.match(/^<\/?([a-z0-9]+)/i);
+    return (_a = match === null || match === void 0 ? void 0 : match[1].toLowerCase()) !== null && _a !== void 0 ? _a : '';
+  }
+  /**
+   * Formats a CSS style string by trimming white space and ensuring consistent semicolon spacing.
+   *
+   * @param {string} style - The CSS style string to format.
+   * @returns {string} The formatted style string.
+   */
+  formatStyle(style) {
+    return style
+      .split(';')
+      .map((s) => s.trim())
+      .filter(Boolean)
+      .join('; ');
+  }
+}
+CodeFormatter.INLINE_TAGS = new Set([
+  'span',
+  'strong',
+  'em',
+  'a',
+  'b',
+  'i',
+  'u',
+  'small',
+  'abbr',
+  'code',
+  'b',
+  'u',
+  's',
+  'mark',
+  'time',
+  'del',
+  'ins',
+]);
+export default new CodeFormatter();