@globalpayments/vega 2.18.1 → 2.20.0

package/dist/esm/stateBackgroundColorFormatter-e705312f.js

@@ -1,82 +0,0 @@
-import { K as isStateVariantTokenType, p as isBackgroundColorTokenType, a as BackgroundColors, d as BackgroundColorMap } from './typeGuard-f33ed2eb.js';
-import { L as LogUtility } from './global-slimmer-registry-16fd7452.js';
-
-/**
- * StateVariantFormatter: Format state token to CSS styles
- */
-class StateVariantFormatter {
-  /**
-   * The function `format` takes an input state variant type and returns formatted CSS styles based on
-   * the input.
-   *
-   * @param {StateVariantType} input - The `format` function takes an `input` parameter of type
-   * `StateVariantType<ManagedStateScopeInput[Flag], State>`. This means that the `input` parameter
-   * should be an object that contains styles for different states, where the keys are state names and
-   * the values are the corresponding styles
-   * @returns {string} The `format` function returns a string that contains CSS styles based on the input
-   * provided. If the input is determined to be a state variant token type, the function generates CSS
-   * styles for each state in the input and returns them joined by newlines. If the input is not a state
-   * variant token type, the function generates CSS styles for the default state and returns them.
-   */
-  format(input) {
-    if (isStateVariantTokenType(input)) {
-      const stateStyles = [];
-      this.getStates().forEach((state) => {
-        const style = this.formatToken(input[state]);
-        if (style) {
-          stateStyles.push(`:host${state === 'default' ? '' : `(:${state})`}{\n\t${style}\n}`);
-        }
-      });
-      return stateStyles.join('\n');
-    }
-    else {
-      const style = this.formatToken(input);
-      return `:host{\n\t${style}\n}`;
-    }
-  }
-}
-
-/**
- * The `StateBackgroundColorFormatter` class in TypeScript formats background color tokens
- * and handles different CSS states.
- */
-class StateBackgroundColorFormatter extends StateVariantFormatter {
-  constructor() {
-    super(...arguments);
-    this.states = ['default', 'hover', 'active', 'focus-visible'];
-  }
-  /**
-   * The function `formatToken` takes a `BackgroundColorsTokenType` input, checks if it is a valid
-   * background color token type, and returns the corresponding CSS background color value or logs a
-   * warning if the input is invalid.
-   *
-   * @param {BackgroundColorsTokenType} input - The `input` parameter is of type
-   * `BackgroundColorsTokenType`, which is used to represent different background color tokens.
-   * @returns {string} The `formatToken` function takes a `BackgroundColorsTokenType` input and checks if it is a
-   * valid background color token type. If it is valid, it retrieves the corresponding color value from
-   * the `BackgroundColorMap` and returns a CSS style string with the background color. If the input is
-   * not valid, it logs a warning message using `LogUtility.warn` and returns an empty string.
-   */
-  formatToken(input) {
-    if (isBackgroundColorTokenType(input)) {
-      const tokenValue = BackgroundColorMap[input];
-      return `background-color: ${tokenValue};`;
-    }
-    else {
-      LogUtility.warn(`The backgroundColor value ${input} is invalid, it must be a value of: `, BackgroundColors);
-      return '';
-    }
-  }
-  /**
-   * The function `getStates` returns an array of `CssStatesType` objects.
-   *
-   * @returns {CssStatesType[]} An array of objects of type CssStatesType, which represents the states stored in the
-   * variable this.states.
-   */
-  getStates() {
-    return this.states;
-  }
-}
-const stateBackgroundColorFormatter = new StateBackgroundColorFormatter();
-
-export { StateVariantFormatter as S, stateBackgroundColorFormatter as s };

package/dist/esm/stringInputFormatterSlimmer-e67c7503.js

@@ -1,341 +0,0 @@
-import { P as isNonNullable } from './typeGuard-f33ed2eb.js';
-import { a as MapToComponentField, V as VegaSlimmer } from './global-slimmer-registry-16fd7452.js';
-
-/**
- * A class for formatting string with the given mask format
- *
- * @augments StringFormatStrategy
- */
-class StringMaskStrategy {
-  /**
-   * It creates a new instance of the Mask class.
-   *
-   * @param {MaskConfig} maskConfig - MaskConfig
-   */
-  constructor(maskConfig) {
-    /**
-     * The insert mode means adding some special character in the input string, will replace part of input string if insertMode set to false.
-     *
-     * @example
-     * mask: ****9999
-     * slot: 9
-     * value = 12345678
-     *
-     * insertMode=true The mask value should be ****1234
-     * insertMode=false The mask value should be ****5678
-     */
-    this.insertMode = true;
-    this.maskConfig = maskConfig;
-    this.slotRegex = new RegExp(maskConfig.slot);
-    this.acceptRegex = new RegExp(maskConfig.accept, 'g');
-    this.insertMode = maskConfig.insertMode === false ? false : true;
-  }
-  /**
-   * Given a string, it replaces the mask with the matched input slot value
-   *
-   * @param {string} input - The input string that needs to be formatted.
-   * @param {number} caretPosition - The current position of caret
-   * @returns {string} The formatted string.
-   */
-  format(input, caretPosition) {
-    if (input.length > this.getLengthLimit() && isNonNullable(caretPosition)) {
-      const rawValueArr = [...input];
-      const exceededLength = input.length - this.getLengthLimit();
-      rawValueArr.splice(caretPosition - exceededLength, exceededLength);
-      return rawValueArr.join('');
-    }
-    return this.replaceMaskWithMatchedInputSlots(input, this.getMatchedInputSlotValue(input));
-  }
-  /**
-   * Get the position of
-   *
-   * @param {string} input - The input string
-   * @param {number} caretPosition - The current position of caret
-   * @returns {number} The new position of caret
-   */
-  calculateCaretPosition(input, caretPosition) {
-    if (!isNonNullable(caretPosition))
-      return null;
-    if (input.length > this.getLengthLimit()) {
-      const exceededLength = input.length - this.getLengthLimit();
-      return caretPosition - exceededLength;
-    }
-    const startValue = input.substring(0, caretPosition);
-    const maskedStartValue = this.format(startValue);
-    return caretPosition + (maskedStartValue.length - startValue.length);
-  }
-  /**
-   * This TypeScript function determines whether a component value should be overridden based on the mask configuration.
-   *
-   * @returns {boolean} The result overrideValue controls whether the component value same as the internal input value after the input blur
-   * return false if property overrideValue is not exist or set to true, return false if maskConfig is not exist
-   */
-  shouldOverrideComponentValueAfterBlur() {
-    if (!this.maskConfig || this.maskConfig.overrideValue !== true) {
-      return false;
-    }
-    else {
-      return true;
-    }
-  }
-  /**
-   * The function shouldTriggerAtInit returns true if the maskConfig is defined and its triggerAtInit
-   * property is set to true, otherwise it returns false.
-   *
-   * @returns {boolean} The function shouldTriggerAtInit() returns a boolean value. If the condition is met
-   * (this.maskConfig is truthy and this.maskConfig.triggerAtInit is true), it returns true. Otherwise,
-   * it returns false.
-   */
-  shouldTriggerAtInit() {
-    if (!this.maskConfig || this.maskConfig.triggerAtInit !== true) {
-      return false;
-    }
-    else {
-      return true;
-    }
-  }
-  /**
-   * Get the length limit by mask
-   *
-   * @returns {number} the max limit length
-   */
-  getLengthLimit() {
-    return this.maskConfig.mask.length;
-  }
-  /**
-   * Given a string, return an array of all the digits in that string
-   *
-   * @param {string} input - The input string to be parsed.
-   * @returns {string[]} - An array of strings.
-   */
-  getMatchedInputSlotValue(input) {
-    return input.match(this.acceptRegex) || [];
-  }
-  /**
-   * Replace the mask with the matched input slots
-   *
-   * @param {string} input - The input string that is being typed by the user.
-   * @param {string[]} matchedInputSlot - an array of the input slots that were matched by the mask.
-   * @returns {string} The result string builder.
-   */
-  replaceMaskWithMatchedInputSlots(input, matchedInputSlot) {
-    const resultStringBuilder = [];
-    let resultStringBuilderCursor = -1;
-    for (let i = 0; i < this.maskConfig.mask.length; i++) {
-      const maskChar = this.maskConfig.mask.charAt(i);
-      if (this.slotRegex.test(maskChar) && matchedInputSlot.length) {
-        const inputSlot = matchedInputSlot.shift();
-        if (inputSlot) {
-          resultStringBuilder.push(inputSlot);
-          resultStringBuilderCursor = i;
-        }
-      }
-      else {
-        if (!this.insertMode) {
-          matchedInputSlot.shift();
-        }
-        if (input.charAt(i) === maskChar) {
-          resultStringBuilderCursor = i;
-        }
-        resultStringBuilder.push(maskChar);
-      }
-    }
-    //The replaceMode result length should be the origin input length
-    const resultLength = this.insertMode ? resultStringBuilderCursor + 1 : input.length;
-    return resultStringBuilder.join('').slice(0, resultLength);
-  }
-}
-StringMaskStrategy.PHONE_MASK = new StringMaskStrategy({
-  mask: '(999) 999-9999',
-  slot: '9',
-  accept: /\d/g,
-});
-StringMaskStrategy.ZIPCODE_MASK = new StringMaskStrategy({
-  mask: '99999',
-  slot: '9',
-  accept: /\d/g,
-});
-StringMaskStrategy.TAX_ID_MASK = new StringMaskStrategy({
-  mask: '99-9999999',
-  slot: '9',
-  accept: /\d/g,
-});
-
-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 `StringInputFormatterSlimmer` class in TypeScript is used to format input values based on specified strategies and handle events like keydown, blur, and focus. */
-class StringInputFormatterSlimmer extends VegaSlimmer {
-  constructor() {
-    super(...arguments);
-    this.inputFlag = true;
-    this.blurFlag = true;
-    /**
-     * restore input value
-     *
-     * @param {InputEvent} e - focus event
-     */
-    this.onFocus = (e) => {
-      if (this.host && this.host['value']) {
-        const target = e.target;
-        const rawValue = target.value;
-        const componentValue = this.host['value'];
-        if (rawValue !== componentValue) {
-          this.inputElement.value = componentValue;
-        }
-      }
-    };
-    /**
-     * A function update the value of the input element by inputFormatStrategy output.
-     *
-     * @param {InputEvent} e - blur event
-     */
-    this.onBlur = (e) => {
-      this.blurFlag = false;
-      if (this.blurFormatStrategy) {
-        const target = e.target;
-        const rawValue = target.value;
-        const maskedValue = this.blurFormatStrategy.format(rawValue);
-        this.updateInputValue(rawValue, maskedValue);
-        if (this.host &&
-          this.blurFormatStrategy.shouldOverrideComponentValueAfterBlur &&
-          this.blurFormatStrategy.shouldOverrideComponentValueAfterBlur()) {
-          this.host['value'] = maskedValue;
-        }
-      }
-    };
-    /**
-     * A function update the value of the input element by inputFormatStrategy output.
-     *
-     * @param {InputEvent} e - input event
-     */
-    this.onKeyDown = (e) => {
-      this.inputFlag = false;
-      const target = e.target;
-      const rawValue = target.value;
-      const caretPosition = target.selectionStart; // selectionStart is nullable, link https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-textarea/input-selectionstart
-      if (this.inputFormatStrategy) {
-        const maskedValue = this.inputFormatStrategy.format(rawValue, caretPosition);
-        this.updateInputValue(rawValue, maskedValue);
-        this.updateInputCaretPosition(rawValue, caretPosition);
-      }
-    };
-  }
-  /**
-   * The setup function initializes input element event listeners based on input and blur format strategies.
-   */
-  setup() {
-    this.destroy();
-    const inputElement = this.getInputElementRef();
-    if (inputElement) {
-      this.inputElement = inputElement;
-      this.inputFormatStrategy = this.getInputModeStrategy();
-      this.blurFormatStrategy = this.getBlurModeStrategy();
-      this.onInit();
-      if (this.inputFormatStrategy) {
-        this.inputElement.addEventListener('input', this.onKeyDown, { capture: true });
-      }
-      if (this.blurFormatStrategy) {
-        this.inputElement.addEventListener('blur', this.onBlur, { capture: true });
-        this.inputElement.addEventListener('focus', this.onFocus, { capture: true });
-      }
-    }
-  }
-  /**
-   * It removes the event listener from the input element.
-   */
-  destroy() {
-    if (this.inputElement) {
-      if (this.inputFormatStrategy) {
-        this.inputElement.removeEventListener('input', this.onKeyDown, { capture: true });
-      }
-      if (this.blurFormatStrategy) {
-        this.inputElement.removeEventListener('blur', this.onBlur, { capture: true });
-        this.inputElement.removeEventListener('focus', this.onFocus, { capture: true });
-      }
-    }
-  }
-  /**
-   * The `onInit` function checks for specific feature flags and conditions to format input values
-   * accordingly.
-   */
-  onInit() {
-    var _a, _b, _c, _d;
-    if (((_b = (_a = this.inputFormatStrategy) === null || _a === void 0 ? void 0 : _a.shouldTriggerAtInit) === null || _b === void 0 ? void 0 : _b.call(_a)) && !this.isOnFocus() && this.inputFlag) {
-      this.inputFlag = false;
-      this.updateInputValueOnInit('input');
-    }
-    if (((_d = (_c = this.blurFormatStrategy) === null || _c === void 0 ? void 0 : _c.shouldTriggerAtInit) === null || _d === void 0 ? void 0 : _d.call(_c)) && !this.isOnFocus() && this.blurFlag) {
-      this.blurFlag = false;
-      this.updateInputValueOnInit('blur');
-    }
-  }
-  /*
-   * The below method is e2e-test covered in
-   * @see{module:vega-input-credit-card-dynamic-mask-e2e}
-   */
-  /* istanbul ignore next */
-  /**
-   * The function `isOnFocus` checks if the input element is currently focused.
-   *
-   * @returns {boolean} The method `isOnFocus()` is returning a `Nullable<boolean>`, which means it can return
-   * either a boolean value or null. The method checks if the `inputElement` is currently focused and
-   * returns true if it is focused, false if it is not focused, or null if the `inputElement` is not
-   * found.
-   */
-  isOnFocus() {
-    return this.inputElement.matches(':focus');
-  }
-  /**
-   * Update input value
-   *
-   * @param {string} rawValue - the original value
-   * @param {string} maskedValue - masked value
-   */
-  updateInputValue(rawValue, maskedValue) {
-    // link: https://stackoverflow.com/questions/52003841/why-doesnt-event-target-value-include-and-e-for-number-inputs
-    // If the input value is '123.', '123' will be got from `target.value` when the input element type is number
-    // '123.' will be formatted to '123', then `this.inputElement.value = 123`, '.' will never be filled in
-    if (maskedValue !== rawValue) {
-      this.inputElement.value = maskedValue;
-    }
-  }
-  /**
-   * Updated the input caret position after the mask format
-   *
-   * @param {string} rawValue - The original input value
-   * @param {Nullable<number>} caretPosition - The current input caret position
-   */
-  updateInputCaretPosition(rawValue, caretPosition) {
-    var _a, _b, _c;
-    const newCaretPosition = (_c = (_b = (_a = this.inputFormatStrategy).calculateCaretPosition) === null || _b === void 0 ? void 0 : _b.call(_a, rawValue, caretPosition)) !== null && _c !== void 0 ? _c : caretPosition;
-    if (isNonNullable(newCaretPosition)) {
-      this.inputElement.setSelectionRange(newCaretPosition, newCaretPosition);
-    }
-  }
-  /**
-   * The function `updateInputValueOnInit` updates the input value based on a specified strategy.
-   *
-   * @param {string} strategy - The `strategy` parameter is a string that determines which formatting
-   * strategy to use when updating the input value. It can have two possible values: 'input' or any other
-   * value.
-   */
-  updateInputValueOnInit(strategy) {
-    const rawValue = this.inputElement.value;
-    const maskedValue = strategy === 'input'
-      ? // eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
-        this.inputFormatStrategy.format(rawValue)
-      : // eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
-        this.blurFormatStrategy.format(rawValue);
-    this.updateInputValue(rawValue, maskedValue);
-    strategy === 'input' && (this.host['value'] = maskedValue);
-  }
-}
-__decorate([
-  MapToComponentField()
-], StringInputFormatterSlimmer.prototype, "host", void 0);
-
-export { StringInputFormatterSlimmer as S, StringMaskStrategy as a };

package/dist/esm/subStateObserverSlimmer-2a8a615e.js

@@ -1,200 +0,0 @@
-import { V as VegaSlimmer, a as MapToComponentField, M as MapToComponentMethod } from './global-slimmer-registry-16fd7452.js';
-import { c as createDynamicSlimmer } from './dynamic-slimmer-ef83e258.js';
-import { C as ChangeManager } from './changeManager-d60d98c8.js';
-import { O as Observer, d as domNodeSubjectFactory } from './domNodeSubjectObserverFactory-a764a6df.js';
-import { e as VegaInternalSubStatePull, f as VegaInternalSubStatePush } from './vegaInternalEventId-bde5d617.js';
-import { f as findParent } from './ui-28499aab.js';
-
-/**
- * Sub state notify slimmer
- */
-class SubStateNotifySlimmerBase extends VegaSlimmer {
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  constructor({ propName }) {
-    super();
-    /**
-     * Checks if the input `host` matches the current `host` and `stateName` matches the current `propName`.
-     *
-     * @param {unknown} input - The `input` parameter is of type `unknown`, which means it can be any type.
-     * @returns {boolean} a boolean value indicating whether the input is an acceptable table observer.
-     */
-    this.isAcceptableObserverPayload = (input) => {
-      return input.host === this.host && input.stateName === this.propName;
-    };
-    this.propName = propName;
-  }
-  /**
-   * Register the observer in connectedCallback
-   */
-  connectedCallback() {
-    this.subStateObserver = new Observer(this.isAcceptableObserverPayload.bind(this), (payload) => {
-      payload.callback(this.propValue);
-    });
-    ChangeManager.register(domNodeSubjectFactory.getSubject(this.host, VegaInternalSubStatePull), this.subStateObserver);
-  }
-  /**
-   * unregister the observer in disconnectedCallback
-   */
-  disconnectedCallback() {
-    ChangeManager.unregister(domNodeSubjectFactory.getSubject(this.host, VegaInternalSubStatePull), this.subStateObserver);
-  }
-  /**
-   * Notify the children component which prop has been changed in the parent component
-   */
-  subStateNotify() {
-    ChangeManager.notify(domNodeSubjectFactory.getSubject(this.host, VegaInternalSubStatePush), {
-      host: this.host,
-      stateName: this.propName,
-      value: this.propValue,
-    });
-  }
-}
-
-/**
- * Create dynamic subState notify slimmer
- *
- * @param {ClassPrototype} mapFromClass - It represents the class that you want to map from.
- * @param {string} propName - The parent component prop name
- * @param {string} watchMethodName - The watch method name of prop change
- * @returns {SubStateNotifySlimmerBase} - SubState notify slimmer
- */
-function createSubStateNotifySlimmer(mapFromClass, propName, watchMethodName) {
-  return createDynamicSlimmer(mapFromClass, SubStateNotifySlimmerBase, [
-    { mapFrom: 'host', mapTo: 'host' },
-    { mapFrom: propName, mapTo: 'propValue' },
-  ], [
-    { mapFrom: watchMethodName, mapTo: 'subStateNotify' },
-    { mapFrom: 'connectedCallback', mapTo: 'connectedCallback' },
-    { mapFrom: 'disconnectedCallback', mapTo: 'disconnectedCallback' },
-  ], [
-    {
-      propName: propName,
-    },
-  ]);
-}
-
-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 subState observer that to sync up the parent state to the children components.
- */
-class SubStateObserverSlimmer extends VegaSlimmer {
-  /**
-   * @param {SubStateObserverEntry} observerEntry - observerEntry is the object that contains the parent state and the state name.
-   */
-  constructor(observerEntry) {
-    super();
-    /**
-     * The function checks if the input object has a 'host' property that matches the parent host and a 'stateName' property.
-     *
-     * @param {unknown} input - The `input` parameter is of type `unknown`, which means it can be any type.
-     * @returns {boolean} a boolean value indicating whether the input is an acceptable observer payload.
-     */
-    this.isAcceptableObserverPayload = (input) => {
-      return input['host'] === this.parent;
-    };
-    this.observerEntry = observerEntry;
-  }
-  /**
-   * Initialize the subState observer.
-   */
-  connectedCallback() {
-    this.parent = this.getParent();
-    if (!this.parent)
-      return;
-    const { subStates } = this.observerEntry;
-    this.subStateObserver = new Observer(this.isAcceptableObserverPayload, (payload) => {
-      const subState = subStates.find((subState) => subState.parentStateName === payload.stateName);
-      if (subState) {
-        this.updateState(subState, payload.value);
-      }
-    });
-    ChangeManager.register(domNodeSubjectFactory.getSubject(this.parent, VegaInternalSubStatePush), this.subStateObserver);
-    if (this.observerEntry.pullStatesWhenReattached && this.host.classList.contains('hydrated')) {
-      this.parent = this.getParent();
-      this.pullStates();
-    }
-  }
-  /**
-   * Unregister the observer when disconnectedCallback
-   */
-  disconnectedCallback() {
-    if (!this.parent)
-      return;
-    ChangeManager.unregister(domNodeSubjectFactory.getSubject(this.parent, VegaInternalSubStatePush), this.subStateObserver);
-  }
-  /**
-   * Fetch the parent props when componentWillLoad
-   */
-  componentWillLoad() {
-    this.pullStates();
-  }
-  /**
-   * The function `getParent` returns the parent element of a given host element, based on the observer
-   * entry and appender element.
-   *
-   * @returns {HTMLElement} the parent HTMLElement.
-   */
-  getParent() {
-    if (typeof this.observerEntry.parent === 'string') {
-      return findParent(this.host, this.observerEntry.parent);
-    }
-    else {
-      return this.observerEntry.parent();
-    }
-  }
-  /**
-   * Update the state with new value
-   *
-   * @param {SubStateEntry} subState - current state entry
-   * @param {unknown} value - new value
-   */
-  updateState(subState, value) {
-    if (subState.callback) {
-      subState.callback(value);
-    }
-    else {
-      this[subState.subStateName] = value;
-    }
-  }
-  /**
-   * The `pullStates` function iterates through subStates and notifies the ChangeManager to update the
-   * state based on the callback function provided.
-   *
-   * @returns {void} If the `this.parent` property is falsy, the `pullStates` method will return early and not
-   * execute the rest of the code inside the method.
-   */
-  pullStates() {
-    if (!this.parent)
-      return;
-    const { subStates } = this.observerEntry;
-    subStates.forEach((subState) => {
-      ChangeManager.notify(domNodeSubjectFactory.getSubject(this.parent, VegaInternalSubStatePull), {
-        host: this.parent,
-        stateName: subState.parentStateName,
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        callback: (value) => {
-          this.updateState(subState, value);
-        },
-      });
-    });
-  }
-}
-__decorate([
-  MapToComponentField()
-], SubStateObserverSlimmer.prototype, "host", void 0);
-__decorate([
-  MapToComponentMethod('connectedCallback')
-], SubStateObserverSlimmer.prototype, "connectedCallback", null);
-__decorate([
-  MapToComponentMethod('disconnectedCallback')
-], SubStateObserverSlimmer.prototype, "disconnectedCallback", null);
-__decorate([
-  MapToComponentMethod('componentWillLoad')
-], SubStateObserverSlimmer.prototype, "componentWillLoad", null);
-
-export { SubStateObserverSlimmer as S, createSubStateNotifySlimmer as c };