npm - art-bd-ui - Versions diffs - 1.0.39 → 1.0.41 - Mend

art-bd-ui 1.0.39 → 1.0.41

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3768) hide show

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js ADDED Viewed

@@ -0,0 +1,64 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getBoundingClientRect = require('./getBoundingClientRect.js');
+var getNodeScroll = require('./getNodeScroll.js');
+var getNodeName = require('./getNodeName.js');
+var instanceOf = require('./instanceOf.js');
+var getWindowScrollBarX = require('./getWindowScrollBarX.js');
+var getDocumentElement = require('./getDocumentElement.js');
+var isScrollParent = require('./isScrollParent.js');
+var math = require('../utils/math.js');
+function isElementScaled(element) {
+  var rect = element.getBoundingClientRect();
+  var scaleX = math.round(rect.width) / element.offsetWidth || 1;
+  var scaleY = math.round(rect.height) / element.offsetHeight || 1;
+  return scaleX !== 1 || scaleY !== 1;
+} // Returns the composite rect of an element relative to its offsetParent.
+// Composite means it takes into account transforms as well as layout.
+function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  var isOffsetParentAnElement = instanceOf.isHTMLElement(offsetParent);
+  var offsetParentIsScaled = instanceOf.isHTMLElement(offsetParent) && isElementScaled(offsetParent);
+  var documentElement = getDocumentElement.default(offsetParent);
+  var rect = getBoundingClientRect.default(elementOrVirtualElement, offsetParentIsScaled, isFixed);
+  var scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  var offsets = {
+    x: 0,
+    y: 0
+  };
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName.default(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
+    isScrollParent.default(documentElement)) {
+      scroll = getNodeScroll.default(offsetParent);
+    }
+    if (instanceOf.isHTMLElement(offsetParent)) {
+      offsets = getBoundingClientRect.default(offsetParent, true);
+      offsets.x += offsetParent.clientLeft;
+      offsets.y += offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX.default(documentElement);
+    }
+  }
+  return {
+    x: rect.left + scroll.scrollLeft - offsets.x,
+    y: rect.top + scroll.scrollTop - offsets.y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+exports.default = getCompositeRect;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js ADDED Viewed

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getWindow = require('./getWindow.js');
+function getComputedStyle(element) {
+  return getWindow.default(element).getComputedStyle(element);
+}
+exports.default = getComputedStyle;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js ADDED Viewed

@@ -0,0 +1,13 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var instanceOf = require('./instanceOf.js');
+function getDocumentElement(element) {
+  // $FlowFixMe[incompatible-return]: assume body is always available
+  return ((instanceOf.isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
+  element.document) || window.document).documentElement;
+}
+exports.default = getDocumentElement;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js ADDED Viewed

@@ -0,0 +1,36 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getDocumentElement = require('./getDocumentElement.js');
+var getComputedStyle = require('./getComputedStyle.js');
+var getWindowScrollBarX = require('./getWindowScrollBarX.js');
+var getWindowScroll = require('./getWindowScroll.js');
+var math = require('../utils/math.js');
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable
+function getDocumentRect(element) {
+  var _element$ownerDocumen;
+  var html = getDocumentElement.default(element);
+  var winScroll = getWindowScroll.default(element);
+  var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
+  var width = math.max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+  var height = math.max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+  var x = -winScroll.scrollLeft + getWindowScrollBarX.default(element);
+  var y = -winScroll.scrollTop;
+  if (getComputedStyle.default(body || html).direction === 'rtl') {
+    x += math.max(html.clientWidth, body ? body.clientWidth : 0) - width;
+  }
+  return {
+    width: width,
+    height: height,
+    x: x,
+    y: y
+  };
+}
+exports.default = getDocumentRect;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js ADDED Viewed

@@ -0,0 +1,12 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+function getHTMLElementScroll(element) {
+  return {
+    scrollLeft: element.scrollLeft,
+    scrollTop: element.scrollTop
+  };
+}
+exports.default = getHTMLElementScroll;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js ADDED Viewed

@@ -0,0 +1,32 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getBoundingClientRect = require('./getBoundingClientRect.js');
+// means it doesn't take into account transforms.
+function getLayoutRect(element) {
+  var clientRect = getBoundingClientRect.default(element); // Use the clientRect sizes if it's not been transformed.
+  // Fixes https://github.com/popperjs/popper-core/issues/1223
+  var width = element.offsetWidth;
+  var height = element.offsetHeight;
+  if (Math.abs(clientRect.width - width) <= 1) {
+    width = clientRect.width;
+  }
+  if (Math.abs(clientRect.height - height) <= 1) {
+    height = clientRect.height;
+  }
+  return {
+    x: element.offsetLeft,
+    y: element.offsetTop,
+    width: width,
+    height: height
+  };
+}
+exports.default = getLayoutRect;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getNodeName.js ADDED Viewed

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+function getNodeName(element) {
+  return element ? (element.nodeName || '').toLowerCase() : null;
+}
+exports.default = getNodeName;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js ADDED Viewed

@@ -0,0 +1,18 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getWindowScroll = require('./getWindowScroll.js');
+var getWindow = require('./getWindow.js');
+var instanceOf = require('./instanceOf.js');
+var getHTMLElementScroll = require('./getHTMLElementScroll.js');
+function getNodeScroll(node) {
+  if (node === getWindow.default(node) || !instanceOf.isHTMLElement(node)) {
+    return getWindowScroll.default(node);
+  } else {
+    return getHTMLElementScroll.default(node);
+  }
+}
+exports.default = getNodeScroll;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js ADDED Viewed

@@ -0,0 +1,75 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getWindow = require('./getWindow.js');
+var getNodeName = require('./getNodeName.js');
+var getComputedStyle = require('./getComputedStyle.js');
+var instanceOf = require('./instanceOf.js');
+var isTableElement = require('./isTableElement.js');
+var getParentNode = require('./getParentNode.js');
+var userAgent = require('../utils/userAgent.js');
+function getTrueOffsetParent(element) {
+  if (!instanceOf.isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
+  getComputedStyle.default(element).position === 'fixed') {
+    return null;
+  }
+  return element.offsetParent;
+} // `.offsetParent` reports `null` for fixed elements, while absolute elements
+// return the containing block
+function getContainingBlock(element) {
+  var isFirefox = /firefox/i.test(userAgent.default());
+  var isIE = /Trident/i.test(userAgent.default());
+  if (isIE && instanceOf.isHTMLElement(element)) {
+    // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
+    var elementCss = getComputedStyle.default(element);
+    if (elementCss.position === 'fixed') {
+      return null;
+    }
+  }
+  var currentNode = getParentNode.default(element);
+  if (instanceOf.isShadowRoot(currentNode)) {
+    currentNode = currentNode.host;
+  }
+  while (instanceOf.isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName.default(currentNode)) < 0) {
+    var css = getComputedStyle.default(currentNode); // This is non-exhaustive but covers the most common CSS properties that
+    // create a containing block.
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') {
+      return currentNode;
+    } else {
+      currentNode = currentNode.parentNode;
+    }
+  }
+  return null;
+} // Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+function getOffsetParent(element) {
+  var window = getWindow.default(element);
+  var offsetParent = getTrueOffsetParent(element);
+  while (offsetParent && isTableElement.default(offsetParent) && getComputedStyle.default(offsetParent).position === 'static') {
+    offsetParent = getTrueOffsetParent(offsetParent);
+  }
+  if (offsetParent && (getNodeName.default(offsetParent) === 'html' || getNodeName.default(offsetParent) === 'body' && getComputedStyle.default(offsetParent).position === 'static')) {
+    return window;
+  }
+  return offsetParent || getContainingBlock(element) || window;
+}
+exports.default = getOffsetParent;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getParentNode.js ADDED Viewed

@@ -0,0 +1,26 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getNodeName = require('./getNodeName.js');
+var getDocumentElement = require('./getDocumentElement.js');
+var instanceOf = require('./instanceOf.js');
+function getParentNode(element) {
+  if (getNodeName.default(element) === 'html') {
+    return element;
+  }
+  return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
+    // $FlowFixMe[incompatible-return]
+    // $FlowFixMe[prop-missing]
+    element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+    element.parentNode || ( // DOM Element detected
+    instanceOf.isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
+    // $FlowFixMe[incompatible-call]: HTMLElement is a Node
+    getDocumentElement.default(element) // fallback
+  );
+}
+exports.default = getParentNode;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js ADDED Viewed

@@ -0,0 +1,23 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getParentNode = require('./getParentNode.js');
+var isScrollParent = require('./isScrollParent.js');
+var getNodeName = require('./getNodeName.js');
+var instanceOf = require('./instanceOf.js');
+function getScrollParent(node) {
+  if (['html', 'body', '#document'].indexOf(getNodeName.default(node)) >= 0) {
+    // $FlowFixMe[incompatible-return]: assume body is always available
+    return node.ownerDocument.body;
+  }
+  if (instanceOf.isHTMLElement(node) && isScrollParent.default(node)) {
+    return node;
+  }
+  return getScrollParent(getParentNode.default(node));
+}
+exports.default = getScrollParent;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js ADDED Viewed

@@ -0,0 +1,38 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getWindow = require('./getWindow.js');
+var getDocumentElement = require('./getDocumentElement.js');
+var getWindowScrollBarX = require('./getWindowScrollBarX.js');
+var isLayoutViewport = require('./isLayoutViewport.js');
+function getViewportRect(element, strategy) {
+  var win = getWindow.default(element);
+  var html = getDocumentElement.default(element);
+  var visualViewport = win.visualViewport;
+  var width = html.clientWidth;
+  var height = html.clientHeight;
+  var x = 0;
+  var y = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    var layoutViewport = isLayoutViewport.default();
+    if (layoutViewport || !layoutViewport && strategy === 'fixed') {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width: width,
+    height: height,
+    x: x + getWindowScrollBarX.default(element),
+    y: y
+  };
+}
+exports.default = getViewportRect;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getWindow.js ADDED Viewed

@@ -0,0 +1,18 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+function getWindow(node) {
+  if (node == null) {
+    return window;
+  }
+  if (node.toString() !== '[object Window]') {
+    var ownerDocument = node.ownerDocument;
+    return ownerDocument ? ownerDocument.defaultView || window : window;
+  }
+  return node;
+}
+exports.default = getWindow;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js ADDED Viewed

@@ -0,0 +1,17 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getWindow = require('./getWindow.js');
+function getWindowScroll(node) {
+  var win = getWindow.default(node);
+  var scrollLeft = win.pageXOffset;
+  var scrollTop = win.pageYOffset;
+  return {
+    scrollLeft: scrollLeft,
+    scrollTop: scrollTop
+  };
+}
+exports.default = getWindowScroll;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js ADDED Viewed

@@ -0,0 +1,20 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getBoundingClientRect = require('./getBoundingClientRect.js');
+var getDocumentElement = require('./getDocumentElement.js');
+var getWindowScroll = require('./getWindowScroll.js');
+function getWindowScrollBarX(element) {
+  // If <html> has a CSS width greater than the viewport, then this will be
+  // incorrect for RTL.
+  // Popper 1 is broken in this case and never had a bug report so let's assume
+  // it's not an issue. I don't think anyone ever specifies width on <html>
+  // anyway.
+  // Browsers where the left scrollbar doesn't cause an issue report `0` for
+  // this (e.g. Edge 2019, IE11, Safari)
+  return getBoundingClientRect.default(getDocumentElement.default(element)).left + getWindowScroll.default(element).scrollLeft;
+}
+exports.default = getWindowScrollBarX;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/instanceOf.js ADDED Viewed

@@ -0,0 +1,27 @@
+'use strict';
+var getWindow = require('./getWindow.js');
+function isElement(node) {
+  var OwnElement = getWindow.default(node).Element;
+  return node instanceof OwnElement || node instanceof Element;
+}
+function isHTMLElement(node) {
+  var OwnElement = getWindow.default(node).HTMLElement;
+  return node instanceof OwnElement || node instanceof HTMLElement;
+}
+function isShadowRoot(node) {
+  // IE 11 has no ShadowRoot
+  if (typeof ShadowRoot === 'undefined') {
+    return false;
+  }
+  var OwnElement = getWindow.default(node).ShadowRoot;
+  return node instanceof OwnElement || node instanceof ShadowRoot;
+}
+exports.isElement = isElement;
+exports.isHTMLElement = isHTMLElement;
+exports.isShadowRoot = isShadowRoot;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js ADDED Viewed

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var userAgent = require('../utils/userAgent.js');
+function isLayoutViewport() {
+  return !/^((?!chrome|android).)*safari/i.test(userAgent.default());
+}
+exports.default = isLayoutViewport;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js ADDED Viewed

@@ -0,0 +1,17 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getComputedStyle = require('./getComputedStyle.js');
+function isScrollParent(element) {
+  // Firefox wants us to check `-x` and `-y` variations as well
+  var _getComputedStyle = getComputedStyle.default(element),
+      overflow = _getComputedStyle.overflow,
+      overflowX = _getComputedStyle.overflowX,
+      overflowY = _getComputedStyle.overflowY;
+  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+exports.default = isScrollParent;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/isTableElement.js ADDED Viewed

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getNodeName = require('./getNodeName.js');
+function isTableElement(element) {
+  return ['table', 'td', 'th'].indexOf(getNodeName.default(element)) >= 0;
+}
+exports.default = isTableElement;

package/dist/cjs/node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js ADDED Viewed

@@ -0,0 +1,33 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+var getScrollParent = require('./getScrollParent.js');
+var getParentNode = require('./getParentNode.js');
+var getWindow = require('./getWindow.js');
+var isScrollParent = require('./isScrollParent.js');
+/*
+given a DOM element, return the list of all scroll parents, up the list of ancesors
+until we get to the top window object. This list is what we attach scroll listeners
+to, because if any of these parent elements scroll, we'll need to re-calculate the
+reference element's position.
+*/
+function listScrollParents(element, list) {
+  var _element$ownerDocumen;
+  if (list === void 0) {
+    list = [];
+  }
+  var scrollParent = getScrollParent.default(element);
+  var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
+  var win = getWindow.default(scrollParent);
+  var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent.default(scrollParent) ? scrollParent : []) : scrollParent;
+  var updatedList = list.concat(target);
+  return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
+  updatedList.concat(listScrollParents(getParentNode.default(target)));
+}
+exports.default = listScrollParents;

package/dist/cjs/node_modules/@popperjs/core/lib/enums.js ADDED Viewed

@@ -0,0 +1,58 @@
+'use strict';
+var top = 'top';
+var bottom = 'bottom';
+var right = 'right';
+var left = 'left';
+var auto = 'auto';
+var basePlacements = [top, bottom, right, left];
+var start = 'start';
+var end = 'end';
+var clippingParents = 'clippingParents';
+var viewport = 'viewport';
+var popper = 'popper';
+var reference = 'reference';
+var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
+  return acc.concat([placement + "-" + start, placement + "-" + end]);
+}, []);
+var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
+  return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
+}, []); // modifiers that need to read the DOM
+var beforeRead = 'beforeRead';
+var read = 'read';
+var afterRead = 'afterRead'; // pure-logic modifiers
+var beforeMain = 'beforeMain';
+var main = 'main';
+var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
+var beforeWrite = 'beforeWrite';
+var write = 'write';
+var afterWrite = 'afterWrite';
+var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
+exports.afterMain = afterMain;
+exports.afterRead = afterRead;
+exports.afterWrite = afterWrite;
+exports.auto = auto;
+exports.basePlacements = basePlacements;
+exports.beforeMain = beforeMain;
+exports.beforeRead = beforeRead;
+exports.beforeWrite = beforeWrite;
+exports.bottom = bottom;
+exports.clippingParents = clippingParents;
+exports.end = end;
+exports.left = left;
+exports.main = main;
+exports.modifierPhases = modifierPhases;
+exports.placements = placements;
+exports.popper = popper;
+exports.read = read;
+exports.reference = reference;
+exports.right = right;
+exports.start = start;
+exports.top = top;
+exports.variationPlacements = variationPlacements;
+exports.viewport = viewport;
+exports.write = write;