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

package/dist/collection/helpers/zindex/test/zIndexManager.test.js

@@ -0,0 +1,176 @@
+import { LogUtility } from '../../../utils/log';
+import ZIndexManager from '../zIndexManager';
+test('zIndexManager should work proper', () => {
+  const container = document.createElement('div');
+  container.innerHTML = `
+    <div id="div-1">
+        <div id="div-2">
+            <div id="div-3"></div>
+        </div>
+    </div>
+    <div id='div-4'></div>
+    <div id='div-5'></div>
+    `;
+  ZIndexManager.setZIndex(null);
+  const div1 = container.querySelector('#div-1');
+  const div2 = container.querySelector('#div-2');
+  const div3 = container.querySelector('#div-3');
+  const div4 = container.querySelector('#div-4');
+  const div5 = container.querySelector('#div-5');
+  ZIndexManager.setZIndex(div1);
+  ZIndexManager.setZIndex(div2);
+  ZIndexManager.setZIndex(div3);
+  ZIndexManager.setZIndex(div4, 'top');
+  ZIndexManager.setZIndex(div5, 'top');
+  expect(container).toEqualHtml(`
+        <div>
+            <div id="div-1" style="z-index: 10001;">
+                <div id="div-2" style="z-index: 10002;">
+                    <div id="div-3" style="z-index: 10003;"></div>
+                </div>
+            </div>
+            <div id="div-4" style="z-index: 11001;"></div>
+            <div id="div-5" style="z-index: 11002;"></div>
+        </div>
+    `);
+  ZIndexManager.removeZIndex(null);
+  ZIndexManager.removeZIndex(div2);
+  ZIndexManager.removeZIndex(div5, 'top');
+  expect(container).toEqualHtml(`
+        <div>
+            <div id="div-1" style="z-index: 10001;">
+                <div id="div-2">
+                    <div id="div-3" style="z-index: 10002;"></div>
+                </div>
+            </div>
+            <div id="div-4" style="z-index: 11001;"></div>
+            <div id="div-5"></div>
+        </div>
+    `);
+  ZIndexManager.setZIndex(div2);
+  ZIndexManager.setZIndex(div5, 'top');
+  expect(container).toEqualHtml(`
+        <div>
+            <div id="div-1" style="z-index: 10001;">
+                <div id="div-2" style="z-index: 10003;">
+                    <div id="div-3" style="z-index: 10002;"></div>
+                </div>
+            </div>
+            <div id="div-4" style="z-index: 11001;"></div>
+            <div id="div-5" style="z-index: 11002;"></div>
+        </div>
+    `);
+  const divCollect = [];
+  for (let i = 0; i < 997; i++) {
+    const div = document.createElement('div');
+    div.setAttribute('id', `${i}`);
+    divCollect.push(div);
+    ZIndexManager.setZIndex(div);
+  }
+  spyOn(LogUtility, 'warn');
+  const div = document.createElement('div');
+  divCollect.push(div);
+  div.setAttribute('id', `${1000}`);
+  ZIndexManager.setZIndex(div);
+  expect(div.style.zIndex).toEqual('11001');
+  expect(container).toEqualHtml(`
+        <div>
+            <div id="div-1" style="z-index: 10001;">
+                <div id="div-2" style="z-index: 10003;">
+                    <div id="div-3" style="z-index: 10002;"></div>
+                </div>
+            </div>
+            <div id="div-4" style="z-index: 11002;"></div>
+            <div id="div-5" style="z-index: 11003;"></div>
+        </div>
+    `);
+  expect(LogUtility.warn).toHaveBeenCalledWith(`The max 'z-index' of base level is '11000', but the current 'z-index' is over, Please optimize the use of 'z-index', otherwise there will be some performance overhead.`);
+});
+test('zIndexManager should work proper while remove first element of stack', () => {
+  const container = document.createElement('div');
+  container.innerHTML = `
+        <div id="div-1"></div>
+    `;
+  const div1 = container.querySelector('#div-1');
+  ZIndexManager.setZIndex(div1);
+  ZIndexManager.removeZIndex(div1);
+  ZIndexManager.setZIndex(div1);
+  expect(container).toEqualHtml(`
+        <div>
+           <div id="div-1" style="z-index: 10001;"></div>
+        </div>
+    `);
+});
+test('zIndexManager should work proper while change basic z-index value', () => {
+  const container = document.createElement('div');
+  container.innerHTML = `
+    <div id="div-1">
+        <div id="div-2">
+            <div id="div-3"></div>
+        </div>
+    </div>
+    `;
+  const div1 = container.querySelector('#div-1');
+  const div2 = container.querySelector('#div-2');
+  const div3 = container.querySelector('#div-3');
+  ZIndexManager.overrideZIndexBasicValues({
+    base: 200,
+    top: 300,
+  });
+  ZIndexManager.setZIndex(div1);
+  ZIndexManager.setZIndex(div2);
+  ZIndexManager.setZIndex(div3, 'top');
+  expect(container).toEqualHtml(`
+        <div>
+            <div id="div-1" style="z-index: 201;">
+                <div id="div-2" style="z-index: 202;">
+                    <div id="div-3" style="z-index: 301;"></div>
+                </div>
+            </div>
+        </div>
+    `);
+  ZIndexManager.overrideZIndexBasicValues({
+    base: 100,
+  });
+  ZIndexManager.setZIndex(div1);
+  ZIndexManager.setZIndex(div2);
+  ZIndexManager.setZIndex(div3, 'top');
+  expect(container).toEqualHtml(`
+        <div>
+            <div id="div-1" style="z-index: 101;">
+                <div id="div-2" style="z-index: 102;">
+                    <div id="div-3" style="z-index: 301;"></div>
+                </div>
+            </div>
+        </div>
+    `);
+  ZIndexManager.overrideZIndexBasicValues({
+    top: 500,
+  });
+  ZIndexManager.setZIndex(div1);
+  ZIndexManager.setZIndex(div2);
+  ZIndexManager.setZIndex(div3, 'top');
+  expect(container).toEqualHtml(`
+        <div>
+            <div id="div-1" style="z-index: 101;">
+                <div id="div-2" style="z-index: 102;">
+                    <div id="div-3" style="z-index: 501;"></div>
+                </div>
+            </div>
+        </div>
+    `);
+});
+test('ZIndexManager should raise error while change basic z-index with invalid value', () => {
+  spyOn(LogUtility, 'error');
+  ZIndexManager.overrideZIndexBasicValues({
+    base: 'a',
+  });
+  expect(LogUtility.error).toBeCalledTimes(1);
+  expect(LogUtility.error).toHaveBeenCalledWith('Change z-index basic value failed, both base level and top level should be of type number!');
+  ZIndexManager.overrideZIndexBasicValues({
+    base: 500,
+    top: 100,
+  });
+  expect(LogUtility.error).toBeCalledTimes(2);
+  expect(LogUtility.error).toHaveBeenCalledWith('Change z-index basic value failed, the base level should be smaller than the top level!');
+});

package/dist/collection/helpers/zindex/vegaZIndexManager.js

@@ -0,0 +1,17 @@
+import ZIndexManager from './zIndexManager';
+/**
+ * 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.overrideZIndexBasicValues(input);
+  }
+}
+export default new VegaZIndexManager();

package/dist/collection/helpers/zindex/zIndexManager.js

@@ -0,0 +1,175 @@
+import { LogUtility } from '../../utils/log';
+import { convertToNumber } from '../../utils/number';
+export const BASE_BASIC_Z_INDEX = 10000;
+export const TOP_BASIC_Z_INDEX = 11000;
+/**
+ * Base level is for custom element such as modal, tooltip, dropdown, sidenav and header.
+ * 	the z-index of current showing element is highly than already show.
+ * Top level is for element that always display to top, such as notification.
+ */
+class ZIndexManager {
+  constructor() {
+    this.baseBasicZIndex = BASE_BASIC_Z_INDEX;
+    this.topBasicZIndex = TOP_BASIC_Z_INDEX;
+    this.levelEntry = {
+      base: {
+        zIndex: this.baseBasicZIndex,
+        elements: [],
+      },
+      top: {
+        zIndex: this.topBasicZIndex,
+        elements: [],
+      },
+    };
+  }
+  /**
+   * "If the element is not already the current element, then increment the z-index and set the element
+   * to the current element."
+   *
+   * The function is a little more complicated than that, but not much. The function takes an element and
+   * a level. The level is optional and defaults to 'base'. The level is used to keep track of the
+   * z-index for each level. The function uses a private variable, levelStatus, to keep track of the
+   * current element and z-index for each level
+   *
+   * @param {HTMLElement} element - The element to set the z-index of.
+   * @param {ZIndexLevelType} [level=base] - The level of the element.
+   * @returns {void}
+   */
+  setZIndex(element, level = 'base') {
+    if (element === null)
+      return;
+    this.removeZIndex(element, level);
+    const zIndexEntry = this.levelEntry[level];
+    if (element && zIndexEntry) {
+      if (level === 'base' && this.isBaseLevelOver()) {
+        LogUtility.warn(`The max 'z-index' of base level is '11000', but the current 'z-index' is over, Please optimize the use of 'z-index', otherwise there will be some performance overhead.`);
+        this.increaseTopEntry();
+      }
+      zIndexEntry.elements.push(element);
+      zIndexEntry.zIndex += 1;
+      element.style.zIndex = zIndexEntry.zIndex.toString();
+    }
+  }
+  /**
+   * It removes the element from the level's array of elements, and then decrements the z-index of all
+   * elements after the removed element
+   *
+   * @param {HTMLElement} element - HTMLElement - The element to move
+   * @param {ZIndexLevelType} [level=base] - Level = 'base'
+   * @returns {void}
+   */
+  removeZIndex(element, level = 'base') {
+    if (element === null)
+      return;
+    const zIndexEntry = this.levelEntry[level];
+    if (element && zIndexEntry) {
+      let startAt = -1;
+      zIndexEntry.elements.forEach((e, index) => {
+        if (e === element)
+          startAt = index;
+        if (startAt >= 0 && index > startAt) {
+          e.style.zIndex = `${convertToNumber(e.style.zIndex) - 1}`;
+        }
+      });
+      if (startAt >= 0) {
+        element.style.removeProperty('z-index');
+        zIndexEntry.elements.splice(startAt, 1);
+        zIndexEntry.zIndex -= 1;
+      }
+    }
+  }
+  /**
+   * The function "overrideZIndexBasicValues" updates the base and top basic z-index values based on the
+   * input provided.
+   *
+   * @param {ZIndexBasicValues} input - The input parameter is of type ZIndexBasicValues, which is an
+   * object with two properties: base and top. Both properties are optional and can be either a number or
+   * undefined.
+   */
+  overrideZIndexBasicValues(input) {
+    const basicValues = this.formatZIndexBasicValues(input);
+    if (this.validBasicValues(basicValues)) {
+      this.updateBasicValues(basicValues);
+    }
+  }
+  /**
+   * The function `formatZIndexBasicValues` takes an input object and returns a new object with additional
+   * properties `base` and `top` added to it.
+   *
+   * @param {ZIndexBasicValues} input - The input parameter is of type ZIndexBasicValues. It is an object
+   * that contains properties for base and top.
+   * @returns {ZIndexBasicValues} - an object that combines the properties of the input object `input` with the properties
+   * `base` and `top`. The values of `base` and `top` are taken from the `this.baseBasicZIndex` and
+   * `this.topBasicZIndex` variables respectively.
+   */
+  formatZIndexBasicValues(input) {
+    return Object.assign({
+      base: this.baseBasicZIndex,
+      top: this.topBasicZIndex,
+    }, input);
+  }
+  /**
+   * The function checks if the input values for base and top levels of a z-index are valid.
+   *
+   * @param {ZIndexBasicValues} input - The input parameter is an object of type ZIndexBasicValues. It
+   * has two properties: base and top. Both properties should be of type number.
+   * @returns {boolean} a boolean value.
+   */
+  validBasicValues(input) {
+    if (typeof input.base !== 'number' || typeof input.top !== 'number') {
+      LogUtility.error('Change z-index basic value failed, both base level and top level should be of type number!');
+      return false;
+    }
+    else if (input.base >= input.top) {
+      LogUtility.error('Change z-index basic value failed, the base level should be smaller than the top level!');
+      return false;
+    }
+    return true;
+  }
+  /**
+   * The function updates the z-index values of elements based on the input values.
+   *
+   * @param {ZIndexBasicValues} input - The input parameter is an object of type ZIndexBasicValues. It
+   * has two properties: base and top, both of which are optional and can be of type number.
+   */
+  updateBasicValues(input) {
+    // update basic z-index value
+    this.baseBasicZIndex = input.base;
+    this.topBasicZIndex = input.top;
+    // update base level entry
+    const baseLevel = this.levelEntry.base;
+    baseLevel.elements.forEach((element, index) => {
+      element.style.zIndex = `${this.baseBasicZIndex + index + 1}`;
+    });
+    baseLevel.zIndex = this.baseBasicZIndex + baseLevel.elements.length;
+    // update top level entry
+    const topLevel = this.levelEntry.top;
+    topLevel.elements.forEach((element, index) => {
+      element.style.zIndex = `${this.topBasicZIndex + index + 1}`;
+    });
+    topLevel.zIndex = this.topBasicZIndex + topLevel.elements.length;
+  }
+  /**
+   * It increases the z-index of all the elements in the top entry by 1
+   *
+   * @returns {void}
+   */
+  increaseTopEntry() {
+    const topEntry = this.levelEntry['top'];
+    topEntry.elements.forEach((element) => {
+      element.style.zIndex = `${convertToNumber(element.style.zIndex) + 1}`;
+    });
+    topEntry.zIndex += 1;
+  }
+  /**
+   * If the z-index of the level is over 1000 greater than the basic z-index of the level, then return
+   * true.
+   *
+   * @returns {boolean} - The zIndexEntry.zIndex - this.getBasicZIndexByLevel(level) >= 1000 is being returned.
+   */
+  isBaseLevelOver() {
+    const baseEntry = this.levelEntry['base'];
+    return baseEntry.zIndex >= this.topBasicZIndex;
+  }
+}
+export default new ZIndexManager();

package/dist/collection/index.js

@@ -1 +1,5 @@
-export {};
+export * from './components';
+export * from './utils/publicApi';
+export * from './constants/publicApi';
+export * from './helpers/publicApi';
+export * from './types/publicApi';

package/dist/collection/polyfill/test-polyfill/e2e/retry.js

@@ -0,0 +1,42 @@
+/* istanbul ignore next */
+/**
+ * helper function for retry
+ *
+ * @param {testCase} testCase retry testCase
+ * @param {retries} retriedTimes retry times
+ * @returns {Promise<void>} return the test result
+ */
+function runTest(testCase, retriedTimes) {
+  return new Promise((resolve, reject) => {
+    const result = testCase(retriedTimes);
+    if (result && result.then) {
+      void result.catch(reject).then(resolve);
+    }
+    else {
+      resolve();
+    }
+  });
+}
+/* istanbul ignore next */
+/**
+ * Polyfill retry function for rerun case if case failed
+ *
+ * @param {description} description testCase description
+ * @param {retries} retries retry times
+ * @param {testCase} testCase retry testCase
+ */
+export async function retry(description, retries, testCase) {
+  test(description, async () => {
+    let latestError = null;
+    for (let tries = 0; tries < retries; tries++) {
+      try {
+        await runTest(testCase, tries);
+        return;
+      }
+      catch (error) {
+        latestError = error;
+      }
+    }
+    throw latestError;
+  });
+}

package/dist/collection/polyfill/test-polyfill/unit/createTouchEvent.js

@@ -0,0 +1,31 @@
+/**
+ * Polyfill new TouchEvent by using createTouchEvent
+ *
+ * @param {element} element target element
+ * @param {touches} touches list include touchX,touchY,touchEventType
+ */
+export function createTouchEvent(element, touches) {
+  for (let i = 0; i < touches.length; i++) {
+    const x = touches[i].touchX;
+    const y = touches[i].touchY;
+    const eventType = touches[i].touchEventType;
+    const touchObj = {
+      identifier: Date.now(),
+      target: element,
+      screenX: x,
+      screenY: y,
+      radiusX: 2.5,
+      radiusY: 2.5,
+      rotationAngle: 10,
+      force: 0.5,
+      clientX: 100,
+      clientY: 150,
+      pageX: 100,
+      pageY: 150,
+    };
+    const touchEvent = new CustomEvent(eventType, { bubbles: true, cancelable: true });
+    touchEvent['touches'] = [touchObj];
+    touchEvent['changedTouches'] = [touchObj];
+    element.dispatchEvent(touchEvent);
+  }
+}

package/dist/collection/polyfill/test-polyfill/unit/events.js

@@ -0,0 +1,100 @@
+import { MockCustomEvent, MockHTMLElement } from '@stencil/core/mock-doc';
+Object.defineProperty(MockHTMLElement.prototype, 'parentElement', {
+  /**
+   * The `get()` method is defining a getter for the `parentElement` property of the `MockHTMLElement`.
+   *
+   * @returns { unknown | null } The element of parent element.
+   */
+  get() {
+    var _a, _b;
+    const slotElement = (_b = (_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('slot');
+    if (slotElement && slotElement.parentNode) {
+      return slotElement.parentNode['host'] && slotElement.parentNode['host'].shadowRoot
+        ? slotElement.parentNode['host']
+        : slotElement.parentNode;
+    }
+    return this.parentNode || (this.host && this.host.shadowRoot === this ? this.host : null);
+  },
+});
+/** The MockEventListener class represents an event listener with a specified type and handler function. */
+class MockEventListener {
+  /**
+   * The constructor function takes a type and a handler function as parameters.
+   *
+   * @param {string} type - The type parameter is a string that represents the type of event that the
+   * handler will be listening for. It could be something like "click", "keydown", or "submit",
+   * depending on the specific event you want to handle.
+   * @param {(e: unknown) => void} handler - The `handler` parameter is a function that takes an argument of type `unknown` and
+   * returns `void`. It is used to handle events of the specified `type`.
+   */
+  constructor(type, handler) {
+    this.type = type;
+    this.handler = handler;
+  }
+}
+Object.defineProperties(Object.getPrototypeOf(MockHTMLElement).prototype, {
+  addEventListener: {
+    /**
+     * support add capture event when using stencil test
+     *
+     * @param {string} type event type
+     * @param {(e: Event) => void} handler event handle
+     * @param {boolean} [useCapture] use capture mode or not
+     */
+    value: function (type, handler, useCapture) {
+      // eslint-disable @typescript-eslint/naming-convention
+      /**
+       * create new event handle base on the param
+       *
+       * @param {Event} e event object
+       */
+      const cloneHandler = function (e) {
+        if (e && e['__stopImmediate'] !== true) {
+          handler(e);
+        }
+      };
+      cloneHandler['__originHandler'] = handler;
+      if (this['__listeners'] == null) {
+        this['__listeners'] = [];
+      }
+      const eventListener = new MockEventListener(type, cloneHandler);
+      if (useCapture) {
+        this['__listeners'].unshift(eventListener);
+      }
+      else {
+        this['__listeners'].push(eventListener);
+      }
+    },
+  },
+  removeEventListener: {
+    /**
+     * remove the event listener from target element
+     *
+     * @param {string} type event type
+     * @param {(e: Event) => void} handler event handler
+     */
+    value: function (type, handler) {
+      if (this != null && Array.isArray(this['__listeners']) === true) {
+        const elmListener = this['__listeners'].find((e) => {
+          return (e['type'] === type &&
+            (e['handler'] === handler || e['handler']['__originHandler'] === handler));
+        });
+        if (elmListener != null) {
+          const index = this['__listeners'].indexOf(elmListener);
+          this['__listeners'].splice(index, 1);
+        }
+      }
+    },
+  },
+});
+Object.defineProperties(Object.getPrototypeOf(MockCustomEvent).prototype, {
+  stopImmediatePropagation: {
+    /**
+     * add custom property `__stopImmediate` when call the method
+     */
+    value: function () {
+      this.cancelBubble = true;
+      this['__stopImmediate'] = true;
+    },
+  },
+});

package/dist/collection/polyfill/test-polyfill/unit/index.js

@@ -0,0 +1,2 @@
+import './events.ts';
+import './methods.ts';

package/dist/collection/polyfill/test-polyfill/unit/methods.js

@@ -0,0 +1,23 @@
+import { MockHTMLElement } from '@stencil/core/mock-doc';
+/**
+ * Polyfill MockHTMLElement#after method by using MockNode#append
+ *
+ * @param {MockNode} node MockNode passed in
+ */
+MockHTMLElement.prototype['after'] = function (node) {
+  this.parentNode.insertBefore(node, this.nextSibling);
+};
+/**
+ * A polyfill for the replaceChildren method
+ *
+ * @param {MockNode[]} nodes MockNode passed in
+ */
+MockHTMLElement.prototype['replaceChildren'] = function (...nodes) {
+  const childNodes = this.childNodes;
+  childNodes.forEach((node) => {
+    node.remove();
+  });
+  nodes.forEach((node) => {
+    this.appendChild(node);
+  });
+};

package/dist/collection/test-assets/test-icons.js

@@ -0,0 +1,5 @@
+export const TestIcons = {
+  'arrow-right': {
+    icon: `<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M17.6485 5.35147C17.1799 4.88284 16.4201 4.88284 15.9515 5.35147C15.4828 5.8201 15.4828 6.5799 15.9515 7.04853L19.903 11H1.15C0.514873 11 0 11.5373 0 12.2C0 12.8627 0.514873 13.4 1.15 13.4H19.903L15.9515 17.3515C15.4828 17.8201 15.4828 18.5799 15.9515 19.0485C16.4201 19.5172 17.1799 19.5172 17.6485 19.0485L23.6485 13.0485C24.1172 12.5799 24.1172 11.8201 23.6485 11.3515L17.6485 5.35147Z" fill="currentColor"></path></svg>`,
+  },
+};

package/dist/collection/types/class.type.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/designToken.type.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/types/publicApi.js

@@ -0,0 +1 @@
+export * from './components.type';

package/dist/collection/types/test/typeGuard.test.js

@@ -0,0 +1,39 @@
+import { isFlexWrapType, isResponsiveType, isSpacingDirection, isStateVariantTokenType } from '../typeGuard';
+test('should get expect result when call function isResponsiveType', async () => {
+  const sizeWithDefault = {
+    default: 'default',
+    M: 'small',
+  };
+  const sizeNoDefault = {
+    M: 'small',
+  };
+  const size = 'small';
+  const sizeEmpty = null;
+  expect(isResponsiveType(sizeWithDefault)).toBeTruthy();
+  expect(isResponsiveType(sizeNoDefault)).toBeTruthy();
+  expect(isResponsiveType(size)).toBeFalsy();
+  expect(isResponsiveType(sizeEmpty)).toBeFalsy();
+});
+test('should get expect result when call function isSpacingDirection', async () => {
+  const num = 8;
+  const stringInvalid = 'top1';
+  const stringValid1 = 'top';
+  const stringValid2 = 'x';
+  expect(isSpacingDirection(num)).toBeFalsy();
+  expect(isSpacingDirection(stringInvalid)).toBeFalsy();
+  expect(isSpacingDirection(stringValid1)).toBeTruthy();
+  expect(isSpacingDirection(stringValid2)).toBeTruthy();
+});
+test('should get expect result when call function isStateVariantTokenType', async () => {
+  expect(isStateVariantTokenType(undefined)).toBeFalsy();
+  expect(isStateVariantTokenType(null)).toBeFalsy();
+  expect(isStateVariantTokenType({})).toBeTruthy();
+  expect(isStateVariantTokenType({ default: '' })).toBeTruthy();
+  expect(isStateVariantTokenType({ default: '', valid: '' })).toBeFalsy();
+});
+test('should get expect result when call function isFlexWrapType', async () => {
+  expect(isFlexWrapType(undefined)).toBeFalsy();
+  expect(isFlexWrapType(null)).toBeFalsy();
+  expect(isFlexWrapType('wrap')).toBeTruthy();
+  expect(isFlexWrapType('wrap1')).toBeFalsy();
+});