@globalpayments/vega 2.45.0 → 2.47.0

package/dist/esm/internal-vega-event-manager-d2c962d2.js

@@ -1,470 +0,0 @@
-import { V as VegaExpand, a as VegaClick, b as VegaDropdownClick, c as VegaClose, e as VegaActionButtonClick, f as VegaChange, g as VegaEventClick, h as VegaDateDblClick, i as VegaMoreActionClick, j as VegaPageUpdate, k as VegaCreate, l as VegaSearch, m as VegaDropdownShow, n as VegaDropdownHide, o as VegaDropdownSearch, p as VegaSearchTrigger, q as VegaLabelButtonClick, r as VegaSelectFileChange, s as VegaRemove, t as VegaRetry, u as VegaPreview, v as VegaFormSubmit, w as VegaFormReset, x as VegaValidate, y as VegaCancel, z as VegaFocus, A as VegaBlur, B as VegaCountryChange, C as VegaShow, D as VegaHide, E as VegaToggleStatus, F as VegaOpen, G as VegaStateUpdate, H as VegaGroupClick, I as VegaMenuClick, J as VegaActionClick, K as VegaPageSizeChange, L as VegaPopoverShow, M as VegaPopoverHide, N as VegaCurrentStepUpdate, P as VegaImageInserted, Q as VegaSelectChange, R as VegaSelectAllChange, S as VegaRowClick, T as VegaRowExpand, U as VegaRowSelect, W as VegaRowSelectAll } from './dom-node-subject-factory-286df025.js';
-import { L as LogUtility } from './global-slimmer-registry-17c4efd4.js';
-
-const entries = [
-  ['vega-accordion', [VegaExpand]],
-  ['vega-app-header-button', [VegaClick, VegaDropdownClick]],
-  ['vega-banner', [VegaClose, VegaActionButtonClick]],
-  ['vega-breadcrumb', [VegaClick]],
-  ['vega-button', [VegaClick]],
-  ['vega-button-circle', [VegaClick]],
-  ['vega-button-group', [VegaClick]],
-  ['vega-button-link', [VegaClick]],
-  ['vega-calendar', [VegaChange, VegaEventClick, VegaDateDblClick, VegaMoreActionClick]],
-  ['vega-carousel', [VegaPageUpdate]],
-  ['vega-checkbox', [VegaChange]],
-  ['vega-checkbox-group', [VegaChange]],
-  ['vega-chip', [VegaClose, VegaClick]],
-  ['vega-color-picker', [VegaChange]],
-  ['vega-combo-box', [VegaChange, VegaCreate, VegaSearch]],
-  ['vega-date-picker', [VegaChange]],
-  [
-    'vega-dropdown',
-    [
-      VegaDropdownShow,
-      VegaDropdownHide,
-      VegaDropdownClick,
-      VegaCreate,
-      VegaDropdownSearch,
-      VegaSearchTrigger,
-    ],
-  ],
-  ['vega-dropdown-item', [VegaClick]],
-  ['vega-field-label', [VegaClick, VegaLabelButtonClick]],
-  ['vega-file-uploader', [VegaChange, VegaSelectFileChange, VegaRemove, VegaRetry, VegaPreview]],
-  ['vega-form', [VegaFormSubmit, VegaFormReset, VegaValidate]],
-  ['vega-image-uploader', [VegaChange, VegaRemove, VegaCancel]],
-  ['vega-input', [VegaChange, VegaFocus, VegaBlur, VegaLabelButtonClick]],
-  ['vega-input-credit-card', [VegaChange, VegaBlur, VegaFocus]],
-  ['vega-input-numeric', [VegaChange]],
-  ['vega-input-phone-number', [VegaChange, VegaCountryChange]],
-  ['vega-input-range', [VegaChange]],
-  ['vega-input-select', [VegaChange, VegaSearch, VegaSearchTrigger, VegaShow, VegaHide]],
-  ['vega-item-toggle', [VegaToggleStatus]],
-  ['vega-modal', [VegaOpen, VegaClose]],
-  ['vega-left-nav', [VegaStateUpdate]],
-  ['vega-left-nav-group', [VegaGroupClick]],
-  ['vega-left-nav-link', [VegaMenuClick]],
-  ['vega-left-nav-section', [VegaActionClick]],
-  ['vega-pagination', [VegaChange, VegaPageSizeChange]],
-  ['vega-popover', [VegaPopoverShow, VegaPopoverHide]],
-  ['vega-progress-tracker', [VegaCurrentStepUpdate]],
-  ['vega-radio', [VegaChange, VegaFocus, VegaBlur]],
-  ['vega-radio-group', [VegaChange]],
-  ['vega-rich-text-editor', [VegaChange, VegaImageInserted]],
-  ['vega-rich-text-editor-toolbar-button', [VegaClick]],
-  ['vega-rich-text-image-editor', [VegaChange]],
-  ['vega-rich-text-link-editor', [VegaChange]],
-  ['vega-segment-control', [VegaChange]],
-  ['vega-selection-chip', [VegaChange]],
-  ['vega-selection-chip-group', [VegaChange]],
-  ['vega-selection-tile', [VegaChange]],
-  ['vega-selection-tile-group', [VegaChange]],
-  ['vega-sidenav', [VegaStateUpdate]],
-  ['vega-sidenav-link', [VegaClick]],
-  ['vega-signature-capture', [VegaChange]],
-  ['vega-stepper', [VegaChange]],
-  ['vega-tab-group', [VegaClick]],
-  [
-    'vega-table',
-    [
-      VegaChange,
-      VegaSelectChange,
-      VegaSelectAllChange,
-      VegaRowClick,
-      VegaRowExpand,
-      VegaRowSelect,
-      VegaRowSelectAll,
-    ],
-  ],
-  ['vega-table-head-cell', [VegaClick]],
-  ['vega-table-row', [VegaClick, VegaExpand]],
-  ['vega-textarea', [VegaChange, VegaBlur]],
-  ['vega-time-picker', [VegaChange]],
-  ['vega-toggle-switch', [VegaChange]],
-];
-const VEGA_COMPONENT_EVENT_MAP = new Map(entries);
-
-/** The code is defining an abstract class called `BaseStrategy` that implements the `JQueryDelegatedEventStrategy` interface. */
-class BaseStrategy {
-  /**
-   * The function "getHostName" returns the VegaComponentName.
-   *
-   * @returns {VegaComponentName} The method is returning the value of the variable "vegaComponentName" of type VegaComponentName.
-   */
-  getHostName() {
-    return this.vegaComponentName;
-  }
-  /**
-   * The function "getEventName" returns the name of an event as a string.
-   *
-   * @returns {VegaNativeEventNameType} a string value, which is the eventName.
-   */
-  getEventName() {
-    return this.eventName;
-  }
-  /**
-   * The function handles a click event on a specified element and dispatches a custom event with an optional detail.
-   *
-   * @param {HTMLElement} vegaHost - The `vegaHost` parameter is an HTMLElement that represents the host element where the event will be dispatched.
-   * @param {unknown} [detail] - The `detail` parameter is an optional argument that represents additional information or data that can be passed along with the event. It can be of any type, as it is defined as `unknown`.
-   * @returns {Event} a custom event of type `Event`.
-   */
-  handle(vegaHost, detail) {
-    const target = this.createEventTarget(vegaHost);
-    target.style.display = 'none';
-    vegaHost.appendChild(target);
-    const clonedEvent = this.createEvent(this.eventName);
-    if (detail) {
-      Object.defineProperty(clonedEvent, 'detail', {
-        configurable: true,
-        value: detail,
-      });
-    }
-    target.dispatchEvent(clonedEvent);
-    target.remove();
-    return clonedEvent;
-  }
-  /**
-   * The function copies attributes from one HTML element to another, excluding attributes starting with "on", "id".
-   *
-   * @param {HTMLElement} element - The `element` parameter is an HTMLElement object that represents the
-   * source element from which the attributes will be copied.
-   * @param {HTMLElement} target - The target parameter is an HTMLElement where the attributes of the
-   * element parameter will be copied to.
-   */
-  copyAttributesToTarget(element, target) {
-    if (element && target) {
-      const attributes = Array.from(element.attributes).filter((attr) => !attr.name.startsWith('on'));
-      attributes.forEach((attr) => {
-        try {
-          target.setAttribute(attr.name, attr.value);
-        }
-        catch (_a) {
-          LogUtility.error(`Delegated strategy copy ${element.tagName} attribute '${attr.name}' error.`);
-        }
-      });
-    }
-  }
-  /**
-   * The function creates and returns a new event object based on the given event name.
-   *
-   * @param {VegaNativeEventNameType} eventName - The eventName parameter is the name of the event that
-   * you want to create. It can be any valid event name, such as "click", "keydown", "mouseover", etc.
-   * @returns {Event} a cloned event object.
-   */
-  createEvent(eventName) {
-    let clonedEvent = new Event(eventName, { bubbles: true, cancelable: true });
-    if (eventName === 'click') {
-      clonedEvent = new MouseEvent(eventName, { bubbles: true, cancelable: true });
-    }
-    return clonedEvent;
-  }
-}
-
-/** The VegaButtonClickStrategy class is responsible for creating a button element when a click event is triggered on a VegaButton component. */
-class VegaButtonClickStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'click';
-    this.vegaComponentName = 'vega-button';
-  }
-  /**
-   * The function creates a new HTML button element based on the properties of a delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaButtonElement, which is a custom element that extends the HTMLButtonElement. It represents
-   * the target button element that will be delegated to create a new button element.
-   * @returns {HTMLButtonElement} an HTMLButtonElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const button = document.createElement('button');
-    this.copyAttributesToTarget(delegatedTarget, button);
-    button.type = delegatedTarget.type;
-    return button;
-  }
-}
-
-/** The VegaCheckboxChangeStrategy class is responsible for creating an event target and handling the change event for Vega checkboxes. */
-class VegaCheckboxChangeStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'change';
-    this.vegaComponentName = 'vega-checkbox';
-  }
-  /**
-   * The function creates and returns a checkbox input element with the same name as the given delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaCheckboxElement, which is a custom element representing a checkbox component in the Vega UI framework.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const input = document.createElement('input');
-    this.copyAttributesToTarget(delegatedTarget, input);
-    input.type = 'checkbox';
-    input.checked = delegatedTarget.checked;
-    return input;
-  }
-}
-
-/** The VegaInputSelectChangeStrategy class is a TypeScript class that extends the BaseStrategy class and is used for handling the 'change' event for Vega input select components. */
-class VegaInputSelectChangeStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'change';
-    this.vegaComponentName = 'vega-input-select';
-  }
-  /**
-   * The function creates a new HTML select element and sets its name attribute based on the name attribute of the delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is of type
-   * HTMLVegaInputSelectElement, which is a custom element that represents an input select element in the Vega framework.
-   * @returns {HTMLSelectElement} an HTMLSelectElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const select = document.createElement('select');
-    this.copyAttributesToTarget(delegatedTarget, select);
-    if (delegatedTarget.value) {
-      select.value = delegatedTarget.value.toString();
-    }
-    return select;
-  }
-}
-
-/** The VegaInputBlurStrategy class is responsible for creating an input element when a blur event is triggered on a VegaInput component. */
-class VegaInputStrategy extends BaseStrategy {
-  /**
-   * The constructor function initializes an instance of a class with a given eventName.
-   *
-   * @param {VegaNativeEventNameType} eventName - The eventName parameter is a string that represents the name of the event.
-   */
-  constructor(eventName) {
-    super();
-    this.vegaComponentName = 'vega-input';
-    this.eventName = eventName;
-  }
-  /**
-   * The function creates a new HTML input element with the same type as the provided delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an
-   * HTMLVegaInputElement, which is a custom type or interface that represents an input element in the
-   * Vega framework. It likely has properties and methods specific to the Vega framework that are not
-   * present in the standard HTMLInputElement.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const input = document.createElement('input');
-    this.copyAttributesToTarget(delegatedTarget, input);
-    input.type = delegatedTarget.type;
-    input.value = delegatedTarget.value;
-    return input;
-  }
-}
-
-/** The VegaRadioChangeStrategy class is responsible for creating an input element for radio buttons and handling the 'change' event. */
-class VegaRadioChangeStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.eventName = 'change';
-    this.vegaComponentName = 'vega-radio';
-  }
-  /**
-   * The function creates and returns a radio input element with the same name as the given delegated target.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an
-   * HTMLVegaRadioElement, which is a custom element that represents a radio button in the Vega UI framework.
-   * @returns {HTMLInputElement} an HTMLInputElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const input = document.createElement('input');
-    this.copyAttributesToTarget(delegatedTarget, input);
-    input.type = 'radio';
-    input.checked = delegatedTarget.checked;
-    return input;
-  }
-}
-
-/** The VegaTextareaChangeStrategy class is a TypeScript class that extends the BaseStrategy class and is used for handling the 'change' event for a VegaTextarea component. */
-class VegaTextareaChangeStrategy extends BaseStrategy {
-  constructor() {
-    super(...arguments);
-    this.vegaComponentName = 'vega-textarea';
-    this.eventName = 'change';
-  }
-  /**
-   * The function creates a textarea element and sets its name attribute based on the name attribute of a delegated target element.
-   *
-   * @param {HTMLElement} delegatedTarget - The delegatedTarget parameter is an HTMLVegaTextElement, which is an element that represents a text input field in the Vega visualization library.
-   * @returns {HTMLTextAreaElement} an HTMLTextAreaElement.
-   */
-  createEventTarget(delegatedTarget) {
-    const textarea = document.createElement('textarea');
-    this.copyAttributesToTarget(delegatedTarget, textarea);
-    textarea.value = delegatedTarget.value;
-    return textarea;
-  }
-}
-
-/** The `JQueryDelegatedStrategyController` class manages delegated event strategies for different HTML elements in a TypeScript application. */
-class JQueryDelegatedStrategyController {
-  /**
-   * The constructor initializes a registry of update strategies for various input events in a Vega application.
-   */
-  constructor() {
-    this.strategyRegistry = new Map();
-    this.updateStrategyRegistry([
-      new VegaButtonClickStrategy(),
-      new VegaInputStrategy('change'),
-      new VegaInputStrategy('focus'),
-      new VegaInputStrategy('blur'),
-      new VegaInputSelectChangeStrategy(),
-      new VegaTextareaChangeStrategy(),
-      new VegaCheckboxChangeStrategy(),
-      new VegaRadioChangeStrategy(),
-    ]);
-  }
-  /**
-   * The function checks if a given event on a specific HTML element is supported for delegation.
-   *
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement, which represents the element on which the event listener is attached.
-   * @param {VegaEventID} eventId - The `eventName` parameter is a string that represents the name of the event.
-   * @returns {boolean} a boolean value.
-   */
-  isSupportDelegated(host, eventId) {
-    let result = false;
-    const componentName = host.tagName.toLowerCase();
-    if (!!this.strategyRegistry.get(componentName) &&
-      !!this.strategyRegistry.get(componentName).get(eventId.getNativeName())) {
-      result = true;
-    }
-    return result;
-  }
-  /**
-   * The function updates the strategy registry with custom strategies based on the event semantics configuration.
-   *
-   * @param {EventSemanticsConfig} eventSemantics - The parameter `eventSemantics` is of type `EventSemanticsConfig`. It is an object that contains two properties: `global` and `components`.
-   */
-  updateRegistryFromEventSemantics(eventSemantics) {
-    let customStrategies = [];
-    const { global, components } = eventSemantics;
-    if (global && Array.isArray(global.jqueryDelegatedEvent)) {
-      customStrategies = customStrategies.concat(global.jqueryDelegatedEvent);
-    }
-    if (components) {
-      for (const name in components) {
-        if (Array.isArray(components[name].jqueryDelegatedEvent)) {
-          customStrategies = customStrategies.concat(components[name].jqueryDelegatedEvent);
-        }
-      }
-    }
-    if (customStrategies.length) {
-      this.updateStrategyRegistry(customStrategies);
-    }
-  }
-  /**
-   * The function returns a delegated event strategy based on the host element and event name.
-   *
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the element on
-   * which the event strategy is being applied. It is the element to which the event listener is attached.
-   * @param {VegaEventID} eventId - The `eventName` parameter is a string that represents the name of the event for which you want to retrieve the strategy.
-   * @returns {Nullable<JQueryDelegatedEventStrategy>} a Nullable<JQueryDelegatedEventStrategy>.
-   */
-  getStrategy(host, eventId) {
-    const componentName = host.tagName.toLowerCase();
-    if (this.strategyRegistry && this.strategyRegistry.get(componentName)) {
-      return this.strategyRegistry.get(componentName).get(eventId.getNativeName());
-    }
-  }
-  /**
-   * The function `overrideCurrentStrategy` updates the strategy registry with a new strategy for a specific host and event.
-   *
-   * @param {JQueryDelegatedEventStrategy[]} strategies - The parameter "strategy" is of type "JQueryDelegatedEventStrategy".
-   */
-  updateStrategyRegistry(strategies) {
-    strategies.forEach((strategy) => {
-      const hostName = strategy.getHostName();
-      const eventName = strategy.getEventName();
-      if (!this.strategyRegistry.get(hostName)) {
-        const map = new Map();
-        map.set(eventName, strategy);
-        this.strategyRegistry.set(hostName, map);
-      }
-      else {
-        this.strategyRegistry.get(hostName).set(eventName, strategy);
-      }
-    });
-  }
-}
-const jqueryDelegatedStrategyController = new JQueryDelegatedStrategyController();
-
-/**
- * The `InternalVegaEventManager` class manages event semantics configuration for global and
- * component-specific settings.
- */
-class InternalVegaEventManager {
-  constructor() {
-    this.config = {};
-    this.defaultEventSemantics = {
-      namespace: 'vega',
-    };
-  }
-  /**
-   * The function sets the semantics configuration for events.
-   *
-   * @param {EventSemanticsConfig} config - The `config` parameter is of type `EventSemanticsConfig`.
-   */
-  setSemantics(config) {
-    this.config = config;
-    jqueryDelegatedStrategyController.updateRegistryFromEventSemantics(config);
-  }
-  /**
-   * The function `getSemantics` returns the event semantics either from the global scope or from the
-   * components within a given host element.
-   *
-   * @param {HTMLElement} host - The host parameter is an HTMLElement that represents the element on
-   * which the event semantics are being checked.
-   * @returns {EventSemantics} The method `getSemantics` returns a value of type `Nullable<EventSemantics>`.
-   */
-  getSemantics(host) {
-    return Object.assign({}, this.defaultEventSemantics, this.getSemanticsInGlobal(), this.getSemanticsInComponents(host));
-  }
-  /**
-   * The function "getEnabledEventIdsByComponent" returns an array of event Ids associated with a given component
-   * name.
-   *
-   * @param {VegaComponentName} componentName - The `componentName` parameter is a string that represents
-   * the name of a Vega component.
-   * @returns {Nullable<VegaEventID[]>} a nullable array of VegaEventID objects.
-   */
-  getEnabledEventIdsByComponent(componentName) {
-    return VEGA_COMPONENT_EVENT_MAP.get(componentName);
-  }
-  /**
-   * The function `getSemanticsInGlobal` returns the global event semantics configuration.
-   *
-   * @returns {Nullable<EventSemantics>} The method is returning a nullable EventSemantics object.
-   */
-  getSemanticsInGlobal() {
-    return this.config.global;
-  }
-  /**
-   * The function `getSemanticsInComponents` returns the semantic configuration for a given component
-   * based on its host element.
-   *
-   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the component for
-   * which we want to retrieve the semantics.
-   * @returns {Nullable<EventSemantics>} a value of type `Nullable<EventSemantics>`.
-   */
-  getSemanticsInComponents(host) {
-    const componentName = host.tagName.toLocaleLowerCase();
-    if (this.config.components &&
-      Object.prototype.hasOwnProperty.call(this.config.components, componentName)) {
-      return this.config.components[componentName];
-    }
-    return null;
-  }
-}
-const internalVegaEventManager = new InternalVegaEventManager();
-
-export { BaseStrategy as B, internalVegaEventManager as i, jqueryDelegatedStrategyController as j };

package/dist/esm/public-rules-596db5ba.js

@@ -1,26 +0,0 @@
-export { C as CheckBoxRequiredRule } from './check-box-required-rule-cb0aa339.js';
-export { D as DateRequiredRule } from './date-required-rule-8944f3bf.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-ef25c4da.js';
-export { T as TimeRangeRequiredRule, a as TimeRequiredRule } from './time-required-rule-a01163b5.js';
-export { T as ToggleSwitchRequiredRule } from './toggle-switch-required-rule-b3cf4302.js';
-export { F as FileUploaderRequiredRule } from './file-uploader-required-rule-ad886d01.js';
-import './internal-form-field-validation-rule.abstract-f5b6bdbf.js';
-import './date-c55b97f0.js';
-import './global-slimmer-registry-17c4efd4.js';
-import './content-state-7e9f3421.js';
-import './change-manager-6a7eb88c.js';
-import './dom-node-subject-factory-286df025.js';
-import './ui-ed1283bb.js';
-import './vega-internal-event-id-d7113cf7.js';
-import './type-guard-158f6d7a.js';
-import './breakpoints-d9faf11c.js';
-import './ui-8424715a.js';
-import './regex-dfe11abf.js';
-import './typography-396de03f.js';
-import './create-public-api-runtime-metrics-slimmer-8ada793f.js';
-import './dynamic-slimmer-90b8af32.js';
-import './_commonjsHelpers-9943807e.js';
-import './static-subject-title-249c76cd.js';

package/dist/esm/remote-invocation-registry-0b330137.js

@@ -1,63 +0,0 @@
-import { C as ChangeManager } from './change-manager-6a7eb88c.js';
-import { O as Observer } from './dom-node-subject-factory-286df025.js';
-
-/**
- * The `RemoteInvocationRegistry` provides methods for performing remote invocation calls
- * and registering remote invocation handlers.
- */
-class RemoteInvocationRegistry {
-  /**
-   * This function performs a remote invocation call and returning the result.
-   *
-   * @typedef T generic type
-   * @param {HTMLElement} subject the dom node subject
-   * @param {unknown[]} args - The `args` parameter of specific method.
-   * @returns {Nullable<T>} The result of call `remoteInvocation`.
-   */
-  call(subject, ...args) {
-    let result = null;
-    ChangeManager.notify(subject, {
-      args,
-      resultCallback: 
-      /* eslint-disable jsdoc/require-jsdoc */
-      (response) => {
-        result = response;
-      },
-    });
-    return result;
-  }
-  /**
-   * The function registers a remote invocation handler.
-   *
-   * @param {HTMLElement} subject the dom node subject
-   * @param {Function}remoteInvocationHandler - The method that is ultimately called.
-   */
-  register(subject, remoteInvocationHandler) {
-    const observer = new Observer(this.isAcceptableObserver.bind(this), (payload) => {
-      const result = remoteInvocationHandler(...payload.args);
-      payload.resultCallback(result);
-    });
-    ChangeManager.register(subject, observer);
-  }
-  /**
-   * The function un-registers a remote invocation call handler.
-   *
-   * @param {HTMLElement} subject the dom node subject
-   */
-  unRegister(subject) {
-    ChangeManager.clearObserversBySubject(subject);
-  }
-  /**
-   * The function isAcceptableObserver checks if the input matches a specified type T.
-   *
-   * @param {unknown} _input - The `_input` parameter is of type `unknown`, which means it can hold any
-   * value.
-   * @returns {boolean} The `isAcceptableObserver` function is returning `true`.
-   */
-  isAcceptableObserver(_input) {
-    return true;
-  }
-}
-const remoteInvocationRegistry = new RemoteInvocationRegistry();
-
-export { remoteInvocationRegistry as r };