@globalpayments/vega 1.0.0 → 2.13.0-backfill-beta.0

package/dist/cjs/_commonjsHelpers-537d719a.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+exports.commonjsGlobal = commonjsGlobal;
+exports.createCommonjsModule = createCommonjsModule;

package/dist/cjs/accessibility-bfa227f6.js

@@ -0,0 +1,17 @@
+'use strict';
+
+/**
+ * It returns a function that takes a KeyboardEvent and dispatches a click event on the currentTarget if the key is Enter.
+ *
+ * @returns {(e: KeyboardEvent) => void } A function that takes a KeyboardEvent and dispatches a click event on the currentTarget.
+ */
+function createEnterKeyHandlerToTriggerClick() {
+  return function (e) {
+    var _a;
+    if (e.key === 'Enter') {
+      (_a = e.currentTarget) === null || _a === void 0 ? void 0 : _a.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+    }
+  };
+}
+
+exports.createEnterKeyHandlerToTriggerClick = createEnterKeyHandlerToTriggerClick;

package/dist/cjs/app-globals-641bb215.js

@@ -0,0 +1,264 @@
+'use strict';
+
+const featureFlagController = require('./featureFlagController-da4c779b.js');
+const index = require('./index-5a81786f.js');
+const globalSlimmerRegistry = require('./global-slimmer-registry-fdb2a041.js');
+const vegaDialogController = require('./vegaDialogController-756ed849.js');
+require('./internalVegaEventManager-a3672e0c.js');
+require('./ui-fa68545a.js');
+const typography = require('./typography-4560e7f1.js');
+const iconManager = require('./iconManager-a9c2209d.js');
+const validCreditCardNumberRule = require('./validCreditCardNumberRule-8721ca05.js');
+const zIndexManager = require('./zIndexManager-48482b9d.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;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * The `VegaWatchMethodCancelSlimmer` class is a TypeScript class that removes
+ * the body of watch methods when a component is not fully instantiated and
+ * applies the original method body when the component is fully instantiated.
+ */
+class VegaWatchMethodCancelSlimmer extends globalSlimmerRegistry.VegaSlimmer {
+  /**
+   * The constructor function takes a component object as a parameter and assigns it to the "component"
+   * property of the class.
+   *
+   * @param {GlobalSlimmerConfig} option - The `option` parameter is of type `GlobalSlimmerConfig`.
+   * It is an object that represents a component in a software system.
+   */
+  constructor(option) {
+    super();
+    this.originalWatchers = new Map();
+    /**
+     * while component reattached, the component will call `connectedCallback` but not call `componentDidLoad`,
+     * so we add this flag to skip empty the watch function in this case.
+     */
+    this.hasDisconnected = false;
+    this.isEnabled = featureFlagController.FeatureFlag.isEnabled('VEGA_REACT.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD') &&
+      featureFlagController.FeatureFlag.isEnabled('VEGA_FRAMEWORK.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD');
+    this.component = option.component;
+  }
+  /**
+   * The connectedCallback function removes the body of watch methods when the component is not fully
+   * instantiated.
+   */
+  connectedCallback() {
+    if (!this.isEnabled)
+      return;
+    if (this.hasDisconnected)
+      return;
+    const watchers = this.component.constructor['watchers'];
+    for (const propName in watchers) {
+      const watchMethodNames = watchers[propName];
+      watchMethodNames.forEach((methodName) => {
+        // while watch method listen by multiple property, we should skip make originalMethod as empty.
+        if (!this.originalWatchers.has(methodName)) {
+          const originalMethod = this.component[methodName];
+          this.originalWatchers.set(methodName, originalMethod);
+          /**
+           * Remove the watch method body when the component not fully instantiated.
+           */
+          // eslint-disable-next-line @typescript-eslint/no-empty-function
+          this.component[methodName] = function () { };
+        }
+      });
+    }
+  }
+  /**
+   * The `@MapToComponentMethod('disconnectedCallback')` decorator is used to map the `disconnectedCallback` method
+   * to the corresponding method in the Stencil component.
+   */
+  disconnectedCallback() {
+    if (!this.isEnabled)
+      return;
+    this.hasDisconnected = true;
+  }
+  /**
+   * The `componentDidLoad` function applies the original method body to the component's watchers when
+   * the component is fully instantiated.
+   */
+  componentDidLoad() {
+    if (!this.isEnabled)
+      return;
+    this.originalWatchers.forEach((method, methodName) => {
+      const originalMethodBody = method;
+      /**
+       * Apply the watch original method body when the component fully instantiated.
+       *
+       * @param {...any} args - watch method args
+       * @returns {unknown} method results
+       */
+      this.component[methodName] = function (...args) {
+        return originalMethodBody.apply(this, args);
+      };
+    });
+  }
+}
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('connectedCallback')
+], VegaWatchMethodCancelSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('disconnectedCallback')
+], VegaWatchMethodCancelSlimmer.prototype, "disconnectedCallback", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('componentDidLoad')
+], VegaWatchMethodCancelSlimmer.prototype, "componentDidLoad", null);
+
+/**
+ * The VegaZIndexManager class calls a method in the ZIndexManager class to
+ * change z-index values based on the input.
+ */
+class VegaZIndexManager {
+  /**
+   * The function "overrideZIndexBasicValues" calls a method in the "ZIndexManager" class to change the
+   * z-index values based on the input.
+   *
+   * @param {ZIndexBasicValues} input - The input parameter is of type ZIndexBasicValues.
+   */
+  overrideZIndexBasicValues(input) {
+    zIndexManager.ZIndexManager.overrideZIndexBasicValues(input);
+  }
+}
+const VegaZIndexManager$1 = new VegaZIndexManager();
+
+/**
+ * Default export function that will be used by stencil global script,
+ * which will be invoked before library loaded.
+ */
+function appGlobalScript () {
+  disableFeatureFlagFromClientGlobal();
+  enableFeatureFlagFromClientGlobal();
+  injectVegaLoaderIntoGlobal();
+  injectVegaNotifyIntoGlobal();
+  injectVegaThemeManagerIntoGlobal();
+  injectVegaLogLevelIntoGlobal();
+  injectVegaDialogIntoGlobal();
+  registerGlobalVegaSlimmers();
+  injectSetEventSemanticsIntoGlobal();
+  injectVegaTypography();
+  injectVegaIconManager();
+  injectVegaZIndexManagerIntoGlobal();
+  injectValidCreditCardNumberRuleIntoGlobal();
+  initRuntimeMetricsTelemetryCollection();
+  injectWaitForVegaIntoGlobal();
+}
+/**
+ * Disable feature flags from the client global defined lists.
+ */
+function disableFeatureFlagFromClientGlobal() {
+  if (globalThis['VegaDisabledFeatureKeys']) {
+    featureFlagController.FeatureFlag.disable(...globalThis['VegaDisabledFeatureKeys']);
+  }
+}
+/**
+ * This function enables feature flags based on a global variable in TypeScript.
+ */
+function enableFeatureFlagFromClientGlobal() {
+  if (globalThis['VegaEnabledFeatureKeys']) {
+    featureFlagController.FeatureFlag.enable(...globalThis['VegaEnabledFeatureKeys']);
+  }
+}
+/**
+ * Inject VegaLoader to global as a public api
+ */
+function injectVegaLoaderIntoGlobal() {
+  globalThis['VegaLoader'] = index.VegaLoader;
+}
+/**
+ * Inject VegaNotify to global as a public api
+ */
+function injectVegaNotifyIntoGlobal() {
+  globalThis.VegaNotify = index.VegaNotify;
+}
+/**
+ * Inject VegaThemeManager to global as a public api
+ */
+function injectVegaThemeManagerIntoGlobal() {
+  globalThis.VegaThemeManager = index.VegaThemeManager;
+}
+/**
+ * Inject VegaLogLevel to global as a public api
+ */
+function injectVegaLogLevelIntoGlobal() {
+  globalThis.setVegaLogLevel = globalSlimmerRegistry.setVegaLogLevel;
+}
+/**
+ * Inject VegaDialog to global as a public api
+ */
+function injectVegaDialogIntoGlobal() {
+  globalThis.VegaDialog = vegaDialogController.VegaDialog;
+}
+/**
+ * register global vega slimmers
+ */
+function registerGlobalVegaSlimmers() {
+  globalSlimmerRegistry.GlobalSlimmersRegistry.register([VegaWatchMethodCancelSlimmer]);
+}
+/**
+ * Inject setEventSemantics to global as a public api
+ */
+function injectSetEventSemanticsIntoGlobal() {
+  globalThis.VegaEventManager = index.VegaEventManager;
+}
+/**
+ * Inject Vega typography stylesheet
+ */
+function injectVegaTypography() {
+  Object.keys(typography.TypographyUrls).forEach((key) => {
+    const { url } = typography.TypographyUrls[key];
+    const typographyLinkId = `vega-typography-${key}`;
+    if (!document.querySelector(`#${typographyLinkId}`)) {
+      const typographyLink = document.createElement('link');
+      typographyLink.id = typographyLinkId;
+      typographyLink.href = url;
+      typographyLink.rel = 'stylesheet';
+      document.head.append(typographyLink);
+    }
+  });
+}
+/**
+ * Inject VegaIconManager to global as a public api
+ */
+function injectVegaIconManager() {
+  globalThis.VegaIconManager = iconManager.VegaIconManager;
+}
+/**
+ * Inject VegaZIndexManager to global as a public api
+ */
+function injectVegaZIndexManagerIntoGlobal() {
+  globalThis.VegaZIndexManager = VegaZIndexManager$1;
+}
+/**
+ * Inject ValidCreditCardNumberRule to global as a public api.
+ */
+function injectValidCreditCardNumberRuleIntoGlobal() {
+  globalThis.ValidCreditCardNumberRule = validCreditCardNumberRule.ValidCreditCardNumberRule;
+}
+/**
+ * init telemetry runtime metrics.
+ * 1. Inject VegaEnvInfo to global
+ * 2. Register runtime metrics add page hide listener method
+ */
+function initRuntimeMetricsTelemetryCollection() {
+  globalThis.VegaEnvInfo = index.vegaEnvManager.getVegaEnv();
+  // eslint-disable-next-line spellcheck/spell-checker
+  void Promise.resolve().then(function () { return require('./index-55e89877.js'); }).then((
+  // eslint-disable-next-line spellcheck/spell-checker
+  module) => {
+    module['default']['init'](featureFlagController.FeatureFlag);
+  });
+}
+/**
+ * Inject waitForVega to global as a public api
+ */
+function injectWaitForVegaIntoGlobal() {
+  globalThis['waitForVega'] = index.waitForVega;
+}
+
+const globalScripts = appGlobalScript;
+
+exports.globalScripts = globalScripts;

package/dist/cjs/array-6e559cde.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const number = require('./number-459031f7.js');
+
+/**
+ * The function checks if two arrays are equal, either in order or ignoring order.
+ *
+ * @param {T[]} first - An array of type T, which is the first array to compare.
+ * @param {T[]} second - `second` is the second array that is being compared for equality with the
+ * first array (`first`).
+ * @param {boolean} [ignoreOrder=false] - The `ignoreOrder` parameter is a boolean flag that determines
+ * whether the order of elements in the arrays should be taken into account when comparing them. If
+ * `ignoreOrder` is set to `true`, the function will return `true` if the two arrays contain the same
+ * elements, regardless of their order
+ * @returns {boolean} The function `isArrayEqual` returns a boolean value indicating whether the two input arrays
+ * are equal or not. If the arrays are equal, it returns `true`, otherwise it returns `false`. The
+ * equality of the arrays can be determined either by comparing the elements in the same order or by
+ * ignoring the order of the elements.
+ */
+const isArrayEqual = (first, second, ignoreOrder = false) => {
+  if (!Array.isArray(first) || !Array.isArray(second) || first.length != second.length)
+    return false;
+  if (ignoreOrder) {
+    const firstSet = new Set(first);
+    const secondSet = new Set(second);
+    return first.every((item) => secondSet.has(item)) && second.every((item) => firstSet.has(item));
+  }
+  else {
+    for (let i = 0; i < first.length; i++) {
+      if (first[i] !== second[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+/**
+ * Return true if all the keys of the object are numbers since it's an array-like object, false otherwise.
+ *
+ * @param {Record<string, unknown>} obj - The object to check.
+ * @returns {boolean} boolean indicating if the object is array-like
+ */
+const isObjectArrayLike = (obj) => {
+  return Object.keys(obj).every((key) => !isNaN(number.convertToNumber(key)));
+};
+/**
+ * Return the longest text length In a string array
+ *
+ * @param {string[]} textArray string array
+ * @returns {number} text length
+ */
+function getLongestTextLengthFromArray(textArray) {
+  let length = 0;
+  textArray.forEach((text) => {
+    length = text && text.length > length ? text.length : length;
+  });
+  return length;
+}
+/**
+ * Convert the single array to nested array base on the lengths of sub-arrays provided, will return the self array if length array not provided
+ *
+ * @example
+ * // return [[1,2],[3,4,5,6]]
+ * revertArrayFromFlatArray([1,2,3,4,5,6],[2,4])
+ * @example
+ * // return [1,2,3,4,5,6]
+ * revertArrayFromFlatArray([1,2,3,4,5,6],[])
+ * @param {T[]} flatArr - an array of elements that have been flattened into a single array.
+ * @param {T[]} lengthArr - `lengthArr` is an array of numbers that specifies the length of each sub-array that the `flatArr`
+ * @returns {T[]|T[][]} The function `revertArrayFromFlatArray` returns either a single-dimensional array of type `T[]` or a two-dimensional array of type `T[][]`
+ */
+function convertArrayToNestedArray(flatArr, lengthArr) {
+  if (lengthArr.length) {
+    const result = [];
+    lengthArr.reduce((startIndex, length) => {
+      result.push(flatArr.slice(startIndex, startIndex + length));
+      return startIndex + length;
+    }, 0);
+    return result;
+  }
+  return flatArr;
+}
+/**
+ * Convert nested array to simple array. the array only handle the directly children array
+ *
+ * @param {T[] | T[][]} arr the array data source
+ * @returns {T[]} result simple array
+ */
+function flatNestedArray(arr) {
+  if (arr && Array.isArray(arr[0])) {
+    return arr.reduce((result, item) => {
+      return result.concat(item);
+    }, []);
+  }
+  return arr;
+}
+/**
+ * sort number object array by given property, and the given property must be a number
+ *
+ * @param {T[] | T[][]} data data source
+ * @param {(data: T) => number} sortBy the object item used to sort by
+ * @returns {T[] | T[][]} result array
+ */
+function sortArrayOrNestedArray(data, sortBy) {
+  let result = data;
+  if (Array.isArray(data[0])) {
+    result = data.map((item) => {
+      item.sort((d1, d2) => sortBy(d1) - sortBy(d2));
+      return item;
+    });
+  }
+  else {
+    result.sort((d1, d2) => sortBy(d1) - sortBy(d2));
+  }
+  return result;
+}
+/**
+ * This function sorts an array or nested array based on a provided accessor function and an existing array of strings.
+ *
+ * @param {unknown[] | unknown[][]} needSortArray - The array or nested array that needs to be sorted.
+ * @param {(item: T) => string} [accessor] - The accessor parameter is an optional function that takes an item from the
+ * needSortArray and returns a string value that will be used for sorting. If not provided, the
+ * function assumes that the items in the array are already strings.
+ * @param {(item:string,nextItem:string)=>number} [existArraySorter] - the sort function for the exist array
+ * @param {string[]} [existArray] - The `existArray` parameter is an optional array of strings that
+ * represents the desired order of the elements in the `needSortArray`. If provided, the function will
+ * sort the elements in `needSortArray` based on their position in `existArray`. If not provided, the default exist array will use the default order of the array
+ * @returns {unknown[] | unknown[][]} The function `sortAsExistArray` returns a sorted array or nested array of type `T[] |
+ * T[][]`. The sorting is based on the order of elements in the `existArray` parameter, or if
+ * `existArray` is not provided, it is based on the order of appearance of elements in the input array
+ * or nested array. The sorting is done using the `sortArrayOrNested
+ */
+function sortAsExistArray(needSortArray, accessor, existArraySorter, existArray) {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  const newAccessor = (item) => typeof accessor === 'function' ? accessor(item) : item;
+  existArray = existArray
+    ? existArray
+    : Array.from(new Set(flatNestedArray(needSortArray).map(newAccessor)));
+  const sorterArray = typeof existArraySorter === 'function' ? existArray.sort(existArraySorter) : existArray;
+  const orderMap = sorterArray.reduce((result, text, index) => {
+    result[text] = index;
+    return result;
+  }, {});
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  const orderBy = (item) => orderMap[newAccessor(item)];
+  return sortArrayOrNestedArray(needSortArray, orderBy);
+}
+/**
+ * The function `findNodeList` iterates through a NodeList and returns the first node that satisfies a
+ * given callback function.
+ *
+ * @param {NodeList} nodeList - NodeList is an array-like object that represents a collection of nodes.
+ * It is typically returned by methods like `querySelectorAll` or `childNodes` in the DOM API. Each
+ * element in the NodeList is a Node object.
+ * @param {(node: Node) => boolean }callBack - The `callBack` parameter is a function that takes a `Node` as an argument and
+ * returns a boolean value. It is used to filter and find a specific node within the `NodeList` based
+ * on certain criteria defined in the callback function.
+ * @returns {Node | undefined} The `findNodeList` function returns a `Node` object if the `callBack` function returns
+ * `true` for any node in the `nodeList`. If none of the nodes satisfy the condition, it returns
+ * `undefined`.
+ */
+function findNodeList(nodeList, callBack) {
+  for (let index = 0; index < nodeList.length; index++) {
+    const node = nodeList[index];
+    if (callBack(node))
+      return node;
+  }
+  return undefined;
+}
+
+exports.convertArrayToNestedArray = convertArrayToNestedArray;
+exports.findNodeList = findNodeList;
+exports.flatNestedArray = flatNestedArray;
+exports.getLongestTextLengthFromArray = getLongestTextLengthFromArray;
+exports.isArrayEqual = isArrayEqual;
+exports.isObjectArrayLike = isObjectArrayLike;
+exports.sortArrayOrNestedArray = sortArrayOrNestedArray;
+exports.sortAsExistArray = sortAsExistArray;

package/dist/cjs/breakpoints-cb3291ba.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const ui = require('./ui-077fc009.js');
+
+/* This file is generated by vega-design 2.0.77 */
+/* eslint-disable */
+/* tslint:disable */
+// prettier-ignore
+const Breakpoints = {
+  "S": 320,
+  "M": 768,
+  "L": 1024,
+  "XL": 1440
+};
+
+/**
+ * Get current breakpoint according current window size
+ *
+ * @returns {BreakpointsTokenType} - current breakpoint
+ */
+const getCurrentBreakpoint = () => {
+  let index = ui.BreakpointKeys.length - 1;
+  const windowWidth = window.innerWidth;
+  for (index; index >= 0; index--) {
+    const breakpointKey = ui.BreakpointKeys[index];
+    if (breakpointKey === 'default')
+      break;
+    if (windowWidth >= Breakpoints[breakpointKey])
+      return breakpointKey;
+  }
+  return 'default';
+};
+/**
+ * Completion breakponts, eg:
+ * {
+ *   default: 'size-12',
+ *   M: 'size-24'
+ * }
+ * it will convert to
+ * {
+ *   default: 'size-12',
+ *   S: 'size-12',
+ *   M: 'size-24',
+ *   L: 'size-24',
+ *   XL: 'size-24',
+ * }
+ *
+ * @param {ResponsiveType<ResponsiveScope>} breakpoints - responsive token
+ * @returns {ResponsiveType<ResponsiveScope>} - completed breakpointss
+ */
+const createCompleteResponsiveMap = (breakpoints) => {
+  let responsiveScope;
+  ui.BreakpointKeys.forEach((breakpoint) => {
+    if (Object.prototype.hasOwnProperty.call(breakpoints, breakpoint)) {
+      responsiveScope = breakpoints[breakpoint];
+    }
+    else {
+      breakpoints[breakpoint] = responsiveScope;
+    }
+  });
+  return breakpoints;
+};
+
+exports.Breakpoints = Breakpoints;
+exports.createCompleteResponsiveMap = createCompleteResponsiveMap;
+exports.getCurrentBreakpoint = getCurrentBreakpoint;

package/dist/cjs/changeManager-7c13d64f.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const globalSlimmerRegistry = require('./global-slimmer-registry-fdb2a041.js');
+
+/**
+ * The ChangeManager is a class that allows observers to register themselves to a subject
+ * and notify the observer if signaled by subject
+ *
+ * @requires Subject
+ * @requires Observer
+ * @property {Map<Subject, Observer<unknown>[]>} pubSubMap - the map of subject to observers
+ */
+class ChangeManager {
+  constructor() {
+    this.pubSubMap = new Map();
+  }
+  /**
+   * If the subject is already in the map, add the observer to the list of observers for that subject. If the subject is not
+   * in the map, add the subject to the map and add the observer to the list of observers for that subject
+   *
+   * @param {Subject} subject - The subject of the event.
+   * @param {Observer<unknown>} observer - The observer that will be registered.
+   */
+  register(subject, observer) {
+    if (this.pubSubMap.has(subject)) {
+      const observers = this.pubSubMap.get(subject);
+      if (observers && !observers.includes(observer)) {
+        observers.push(observer);
+      }
+    }
+    else {
+      this.pubSubMap.set(subject, [observer]);
+    }
+  }
+  /**
+   * If the subject is in the map, remove the observer from the list of observers for that subject
+   *
+   * @param {Subject} subject - The subject of the event.
+   * @param {Observer<unknown>} observer - The observer to be unregistered.
+   */
+  unregister(subject, observer) {
+    if (this.pubSubMap.has(subject)) {
+      const observers = this.pubSubMap.get(subject);
+      if (observers && observers.includes(observer)) {
+        observers.splice(observers.indexOf(observer), 1);
+      }
+    }
+  }
+  /**
+   * The function clears the observers for a given subject in a pub-sub map.
+   *
+   * @param {Subject} subject - The subject parameter is an object that represents the subject of the observer pattern. It is used as a key to identify the observers that are subscribed to it.
+   */
+  clearObserversBySubject(subject) {
+    this.pubSubMap.delete(subject);
+  }
+  /**
+   * If the subject is in the map, then notify all observers of the subject
+   *
+   * @param {Subject} subject - Subject
+   * @param {unknown} payload - The payload to be sent to the observer.
+   */
+  notify(subject, payload) {
+    if (this.pubSubMap.has(subject)) {
+      this.pubSubMap.get(subject).forEach((observer) => {
+        try {
+          observer.notify(payload);
+        }
+        catch (e) {
+          globalSlimmerRegistry.LogUtility.warn(`Encountered error while notifying observer for subject ${subject.getDescription()}`, e);
+        }
+      });
+    }
+  }
+}
+const ChangeManager$1 = new ChangeManager();
+
+exports.ChangeManager = ChangeManager$1;

package/dist/cjs/chevron-down-ca2fa88e.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const chevronUp = {
+  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="M201.4 105.4c12.5-12.5 32.8-12.5 45.3 0l192 192c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L224 173.3 54.6 342.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l192-192z"/></svg>`,
+};
+
+const chevronDown = {
+  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="M201.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 338.7 54.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z"/></svg>`,
+};
+
+exports.chevronDown = chevronDown;
+exports.chevronUp = chevronUp;