@muraldevkit/ui-toolkit 4.67.0 → 4.68.0-dev-5W5E.1

package/dist/esm/utils/getScrollableContainer/getScrollableContainer.js

@@ -0,0 +1,62 @@
+var SCROLLABLE_VALUES = ['auto', 'scroll', 'overlay'];
+
+/**
+ * Determines if an element can scroll on the requested axis.
+ *
+ * @param element - Candidate element to test.
+ * @param axis - Axis to check ('vertical' | 'horizontal'), omit to get both.
+ * @param requireOverflow - When true, the element must currently overflow on the axis; when false, scrollable CSS is sufficient.
+ * @returns if the element can scroll on the requested axis.
+ */
+var isScrollable = (element, axis, requireOverflow) => {
+  var _style$overflowX, _style$overflowY;
+  var style = getComputedStyle(element);
+  var overflowX = (_style$overflowX = style.overflowX) !== null && _style$overflowX !== void 0 ? _style$overflowX : style.overflow;
+  var overflowY = (_style$overflowY = style.overflowY) !== null && _style$overflowY !== void 0 ? _style$overflowY : style.overflow;
+  var canScrollX = SCROLLABLE_VALUES.includes(overflowX);
+  var canScrollY = SCROLLABLE_VALUES.includes(overflowY);
+  var hasHorizontalOverflow = !requireOverflow || element.scrollWidth > element.clientWidth;
+  var hasVerticalOverflow = !requireOverflow || element.scrollHeight > element.clientHeight;
+  if (axis === 'horizontal') {
+    if (requireOverflow) {
+      return canScrollX && hasHorizontalOverflow;
+    } else {
+      return canScrollX;
+    }
+  }
+  if (axis === 'vertical') {
+    if (requireOverflow) {
+      return canScrollY && hasVerticalOverflow;
+    } else {
+      return canScrollY;
+    }
+  }
+  if (requireOverflow) {
+    return canScrollX && canScrollY && hasHorizontalOverflow && hasVerticalOverflow;
+  }
+  return canScrollX && canScrollY;
+};
+
+/**
+ * Get the scrollable container of an element.
+ *
+ * @param element - The element whose scrollable ancestor is needed.
+ * @param axis - Axis to check for scrollability ('vertical' | 'horizontal' | 'both' | 'all'). Defaults to 'vertical'.
+ * @param requireOverflow - When true, element must actually overflow on the axis; when false, only scroll styles are considered. Defaults to false.
+ * @returns The scrollable container for the specified axis.
+ */
+var getScrollableContainer = function getScrollableContainer(element) {
+  var axis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'vertical';
+  var requireOverflow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var scrollableContainer = element.parentElement;
+  while (scrollableContainer) {
+    if (isScrollable(scrollableContainer, axis, requireOverflow)) {
+      return scrollableContainer;
+    }
+    scrollableContainer = scrollableContainer.parentElement;
+  }
+  return document.scrollingElement || document.body;
+};
+
+export { getScrollableContainer };
+//# sourceMappingURL=getScrollableContainer.js.map

package/dist/esm/utils/getScrollableContainer/getScrollableContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getScrollableContainer.js","sources":["../../../../src/utils/getScrollableContainer/getScrollableContainer.ts"],"sourcesContent":["export type ScrollAxis = 'vertical' | 'horizontal' | undefined;\n\nconst SCROLLABLE_VALUES = ['auto', 'scroll', 'overlay'];\n\n/**\n * Determines if an element can scroll on the requested axis.\n *\n * @param element - Candidate element to test.\n * @param axis - Axis to check ('vertical' | 'horizontal'), omit to get both.\n * @param requireOverflow - When true, the element must currently overflow on the axis; when false, scrollable CSS is sufficient.\n * @returns if the element can scroll on the requested axis.\n */\nconst isScrollable = (\n\telement: HTMLElement,\n\taxis: ScrollAxis,\n\trequireOverflow?: boolean\n): boolean => {\n\tconst style = getComputedStyle(element);\n\tconst overflowX = style.overflowX ?? style.overflow;\n\tconst overflowY = style.overflowY ?? style.overflow;\n\tconst canScrollX = SCROLLABLE_VALUES.includes(overflowX);\n\tconst canScrollY = SCROLLABLE_VALUES.includes(overflowY);\n\n\tconst hasHorizontalOverflow = !requireOverflow || element.scrollWidth > element.clientWidth;\n\tconst hasVerticalOverflow = !requireOverflow || element.scrollHeight > element.clientHeight;\n\n\tif (axis === 'horizontal') {\n\t\tif (requireOverflow) {\n\t\t\treturn canScrollX && hasHorizontalOverflow;\n\t\t} else {\n\t\t\treturn canScrollX;\n\t\t}\n\t}\n\n\tif (axis === 'vertical') {\n\t\tif (requireOverflow) {\n\t\t\treturn canScrollY && hasVerticalOverflow;\n\t\t} else {\n\t\t\treturn canScrollY;\n\t\t}\n\t}\n\n\tif (requireOverflow) {\n\t\treturn canScrollX && canScrollY && hasHorizontalOverflow && hasVerticalOverflow;\n\t}\n\n\treturn canScrollX && canScrollY;\n};\n\n/**\n * Get the scrollable container of an element.\n *\n * @param element - The element whose scrollable ancestor is needed.\n * @param axis - Axis to check for scrollability ('vertical' | 'horizontal' | 'both' | 'all'). Defaults to 'vertical'.\n * @param requireOverflow - When true, element must actually overflow on the axis; when false, only scroll styles are considered. Defaults to false.\n * @returns The scrollable container for the specified axis.\n */\nexport const getScrollableContainer = (\n\telement: HTMLElement,\n\taxis: ScrollAxis = 'vertical',\n\trequireOverflow = false\n): HTMLElement => {\n\tlet scrollableContainer = element.parentElement as HTMLElement;\n\n\twhile (scrollableContainer) {\n\t\tif (isScrollable(scrollableContainer, axis, requireOverflow)) {\n\t\t\treturn scrollableContainer;\n\t\t}\n\t\tscrollableContainer = scrollableContainer.parentElement as HTMLElement;\n\t}\n\n\treturn (document.scrollingElement as HTMLElement) || document.body;\n};\n"],"names":["SCROLLABLE_VALUES","isScrollable","element","axis","requireOverflow","_style$overflowX","_style$overflowY","style","getComputedStyle","overflowX","overflow","overflowY","canScrollX","includes","canScrollY","hasHorizontalOverflow","scrollWidth","clientWidth","hasVerticalOverflow","scrollHeight","clientHeight","getScrollableContainer","arguments","length","undefined","scrollableContainer","parentElement","document","scrollingElement","body"],"mappings":"AAEA,IAAMA,iBAAiB,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC;;AAEvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMC,YAAY,GAAGA,CACpBC,OAAoB,EACpBC,IAAgB,EAChBC,eAAyB,KACZ;EAAA,IAAAC,gBAAA,EAAAC,gBAAA;AACb,EAAA,IAAMC,KAAK,GAAGC,gBAAgB,CAACN,OAAO,CAAC;AACvC,EAAA,IAAMO,SAAS,GAAA,CAAAJ,gBAAA,GAAGE,KAAK,CAACE,SAAS,MAAA,IAAA,IAAAJ,gBAAA,KAAA,MAAA,GAAAA,gBAAA,GAAIE,KAAK,CAACG,QAAQ;AACnD,EAAA,IAAMC,SAAS,GAAA,CAAAL,gBAAA,GAAGC,KAAK,CAACI,SAAS,MAAA,IAAA,IAAAL,gBAAA,KAAA,MAAA,GAAAA,gBAAA,GAAIC,KAAK,CAACG,QAAQ;AACnD,EAAA,IAAME,UAAU,GAAGZ,iBAAiB,CAACa,QAAQ,CAACJ,SAAS,CAAC;AACxD,EAAA,IAAMK,UAAU,GAAGd,iBAAiB,CAACa,QAAQ,CAACF,SAAS,CAAC;EAExD,IAAMI,qBAAqB,GAAG,CAACX,eAAe,IAAIF,OAAO,CAACc,WAAW,GAAGd,OAAO,CAACe,WAAW;EAC3F,IAAMC,mBAAmB,GAAG,CAACd,eAAe,IAAIF,OAAO,CAACiB,YAAY,GAAGjB,OAAO,CAACkB,YAAY;EAE3F,IAAIjB,IAAI,KAAK,YAAY,EAAE;AAC1B,IAAA,IAAIC,eAAe,EAAE;MACpB,OAAOQ,UAAU,IAAIG,qBAAqB;AAC3C,IAAA,CAAC,MAAM;AACN,MAAA,OAAOH,UAAU;AAClB,IAAA;AACD,EAAA;EAEA,IAAIT,IAAI,KAAK,UAAU,EAAE;AACxB,IAAA,IAAIC,eAAe,EAAE;MACpB,OAAOU,UAAU,IAAII,mBAAmB;AACzC,IAAA,CAAC,MAAM;AACN,MAAA,OAAOJ,UAAU;AAClB,IAAA;AACD,EAAA;AAEA,EAAA,IAAIV,eAAe,EAAE;AACpB,IAAA,OAAOQ,UAAU,IAAIE,UAAU,IAAIC,qBAAqB,IAAIG,mBAAmB;AAChF,EAAA;EAEA,OAAON,UAAU,IAAIE,UAAU;AAChC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IACaO,sBAAsB,GAAG,SAAzBA,sBAAsBA,CAClCnB,OAAoB,EAGH;AAAA,EAAA,IAFjBC,IAAgB,GAAAmB,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAG,UAAU;AAAA,EAAA,IAC7BlB,eAAe,GAAAkB,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAG,KAAK;AAEvB,EAAA,IAAIG,mBAAmB,GAAGvB,OAAO,CAACwB,aAA4B;AAE9D,EAAA,OAAOD,mBAAmB,EAAE;IAC3B,IAAIxB,YAAY,CAACwB,mBAAmB,EAAEtB,IAAI,EAAEC,eAAe,CAAC,EAAE;AAC7D,MAAA,OAAOqB,mBAAmB;AAC3B,IAAA;IACAA,mBAAmB,GAAGA,mBAAmB,CAACC,aAA4B;AACvE,EAAA;AAEA,EAAA,OAAQC,QAAQ,CAACC,gBAAgB,IAAoBD,QAAQ,CAACE,IAAI;AACnE;;;;"}

package/dist/esm/utils/hasHorizontalScroll/hasHorizontalScroll.js

@@ -0,0 +1,19 @@
+/**
+ * Test if an element has scrollable content in the horizontal axis
+ *
+ * @param element - the element that is scrollable
+ * @returns - object with hasScrollLeft and hasScrollRight properties
+ */
+var hasHorizontalScroll = element => {
+  var _ref = element,
+    scrollLeft = _ref.scrollLeft,
+    offsetWidth = _ref.offsetWidth,
+    scrollWidth = _ref.scrollWidth;
+  return {
+    hasScrollLeft: scrollLeft > 0,
+    hasScrollRight: scrollLeft + offsetWidth < scrollWidth
+  };
+};
+
+export { hasHorizontalScroll };
+//# sourceMappingURL=hasHorizontalScroll.js.map

package/dist/esm/utils/hasHorizontalScroll/hasHorizontalScroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasHorizontalScroll.js","sources":["../../../../src/utils/hasHorizontalScroll/hasHorizontalScroll.ts"],"sourcesContent":["export type HasHorizontalScrollReturn = {\n\thasScrollLeft: boolean;\n\thasScrollRight: boolean;\n};\n\n/**\n * Test if an element has scrollable content in the horizontal axis\n *\n * @param element - the element that is scrollable\n * @returns - object with hasScrollLeft and hasScrollRight properties\n */\nexport const hasHorizontalScroll = (element: HTMLElement): HasHorizontalScrollReturn => {\n\tconst { scrollLeft, offsetWidth, scrollWidth } = element as HTMLElement;\n\treturn {\n\t\thasScrollLeft: scrollLeft > 0,\n\t\thasScrollRight: scrollLeft + offsetWidth < scrollWidth\n\t};\n};\n"],"names":["hasHorizontalScroll","element","_ref","scrollLeft","offsetWidth","scrollWidth","hasScrollLeft","hasScrollRight"],"mappings":"AAKA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,mBAAmB,GAAIC,OAAoB,IAAgC;EACvF,IAAAC,IAAA,GAAiDD,OAAO;IAAhDE,UAAU,GAAAD,IAAA,CAAVC,UAAU;IAAEC,WAAW,GAAAF,IAAA,CAAXE,WAAW;IAAEC,WAAW,GAAAH,IAAA,CAAXG,WAAW;EAC5C,OAAO;IACNC,aAAa,EAAEH,UAAU,GAAG,CAAC;AAC7BI,IAAAA,cAAc,EAAEJ,UAAU,GAAGC,WAAW,GAAGC;GAC3C;AACF;;;;"}

package/dist/esm/utils/hasScrollContent/hasScrollContent.js

@@ -0,0 +1,15 @@
+/**
+ * Test if an element has scrollable content left
+ *
+ * @param {HTMLElement} element - the element you want to test
+ * @returns {HasScrollContentReturn} - object with hasScrollTop and hasScrollBottom properties
+ */
+var hasScrollContent = element => {
+  return {
+    hasScrollBottom: Math.abs(element.scrollHeight - element.scrollTop - element.clientHeight) > 1,
+    hasScrollTop: element.scrollTop > 0
+  };
+};
+
+export { hasScrollContent };
+//# sourceMappingURL=hasScrollContent.js.map

package/dist/esm/utils/hasScrollContent/hasScrollContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasScrollContent.js","sources":["../../../../src/utils/hasScrollContent/hasScrollContent.ts"],"sourcesContent":["export type HasScrollContentReturn = {\n\thasScrollTop: boolean;\n\thasScrollBottom: boolean;\n};\n\n/**\n * Test if an element has scrollable content left\n *\n * @param {HTMLElement} element - the element you want to test\n * @returns {HasScrollContentReturn} - object with hasScrollTop and hasScrollBottom properties\n */\nexport const hasScrollContent = (element: HTMLElement): HasScrollContentReturn => {\n\treturn {\n\t\thasScrollBottom: Math.abs(element.scrollHeight - element.scrollTop - element.clientHeight) > 1,\n\t\thasScrollTop: element.scrollTop > 0\n\t};\n};\n"],"names":["hasScrollContent","element","hasScrollBottom","Math","abs","scrollHeight","scrollTop","clientHeight","hasScrollTop"],"mappings":"AAKA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,gBAAgB,GAAIC,OAAoB,IAA6B;EACjF,OAAO;AACNC,IAAAA,eAAe,EAAEC,IAAI,CAACC,GAAG,CAACH,OAAO,CAACI,YAAY,GAAGJ,OAAO,CAACK,SAAS,GAAGL,OAAO,CAACM,YAAY,CAAC,GAAG,CAAC;AAC9FC,IAAAA,YAAY,EAAEP,OAAO,CAACK,SAAS,GAAG;GAClC;AACF;;;;"}

package/dist/esm/utils/isElementAriaDisabled/isElementAriaDisabled.js

@@ -0,0 +1,14 @@
+/**
+ * Checks if an element has aria-disabled="true"
+ *
+ * @param {HTMLElement | null | undefined} element - The element to check for aria-disabled attribute
+ * @returns {boolean} - true if the element has aria-disabled="true", false otherwise
+ */
+var isElementAriaDisabled = element => {
+  if (!element) return false;
+  var ariaDisabled = element.getAttribute('aria-disabled');
+  return (ariaDisabled === null || ariaDisabled === void 0 ? void 0 : ariaDisabled.trim()) === 'true';
+};
+
+export { isElementAriaDisabled };
+//# sourceMappingURL=isElementAriaDisabled.js.map

package/dist/esm/utils/isElementAriaDisabled/isElementAriaDisabled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isElementAriaDisabled.js","sources":["../../../../src/utils/isElementAriaDisabled/isElementAriaDisabled.ts"],"sourcesContent":["/**\n * Checks if an element has aria-disabled=\"true\"\n *\n * @param {HTMLElement | null | undefined} element - The element to check for aria-disabled attribute\n * @returns {boolean} - true if the element has aria-disabled=\"true\", false otherwise\n */\nexport const isElementAriaDisabled = (element: HTMLElement | null | undefined): boolean => {\n\tif (!element) return false;\n\n\tconst ariaDisabled = element.getAttribute('aria-disabled');\n\treturn ariaDisabled?.trim() === 'true';\n};\n"],"names":["isElementAriaDisabled","element","ariaDisabled","getAttribute","trim"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,qBAAqB,GAAIC,OAAuC,IAAc;AAC1F,EAAA,IAAI,CAACA,OAAO,EAAE,OAAO,KAAK;AAE1B,EAAA,IAAMC,YAAY,GAAGD,OAAO,CAACE,YAAY,CAAC,eAAe,CAAC;EAC1D,OAAO,CAAAD,YAAY,KAAA,IAAA,IAAZA,YAAY,KAAA,MAAA,GAAA,MAAA,GAAZA,YAAY,CAAEE,IAAI,EAAE,MAAK,MAAM;AACvC;;;;"}

package/dist/esm/utils/isElementScrollable/index.js

@@ -0,0 +1,12 @@
+/**
+ * Test if an element is scrollable
+ *
+ * @param {HTMLElement} element - the element you want to test
+ * @returns {boolean} - true if the element is scrollable, false if it is not scrollable
+ */
+var isElementScrollable = element => {
+  return element.scrollHeight > element.clientHeight;
+};
+
+export { isElementScrollable };
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/isElementScrollable/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/utils/isElementScrollable/index.ts"],"sourcesContent":["/**\n * Test if an element is scrollable\n *\n * @param {HTMLElement} element - the element you want to test\n * @returns {boolean} - true if the element is scrollable, false if it is not scrollable\n */\nexport const isElementScrollable = (element: HTMLElement): boolean => {\n\treturn element.scrollHeight > element.clientHeight;\n};\n"],"names":["isElementScrollable","element","scrollHeight","clientHeight"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,mBAAmB,GAAIC,OAAoB,IAAc;AACrE,EAAA,OAAOA,OAAO,CAACC,YAAY,GAAGD,OAAO,CAACE,YAAY;AACnD;;;;"}

package/dist/esm/utils/isImagePath/index.js

@@ -0,0 +1,21 @@
+import * as path from 'path-browserify';
+
+/**
+ * Checks if a passed image string is a valid URL
+ *
+ * @param {string} image - the image string being tested
+ * @returns {boolean} - if the image is an image URL
+ */
+var isImagePath = image => {
+  try {
+    if (typeof image !== 'string') return false;
+    var result = path.parse(image);
+    if (!result) throw result;
+  } catch (err) {
+    return false;
+  }
+  return true;
+};
+
+export { isImagePath };
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/isImagePath/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/utils/isImagePath/index.ts"],"sourcesContent":["import * as path from 'path-browserify';\n\n/**\n * Checks if a passed image string is a valid URL\n *\n * @param {string} image - the image string being tested\n * @returns {boolean} - if the image is an image URL\n */\nexport const isImagePath = (image: string): image is string => {\n\ttry {\n\t\tif (typeof image !== 'string') return false;\n\n\t\tconst result = path.parse(image);\n\t\tif (!result) throw result;\n\t} catch (err) {\n\t\treturn false;\n\t}\n\n\treturn true;\n};\n"],"names":["isImagePath","image","result","path","parse","err"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,WAAW,GAAIC,KAAa,IAAsB;EAC9D,IAAI;AACH,IAAA,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE,OAAO,KAAK;AAE3C,IAAA,IAAMC,MAAM,GAAGC,IAAI,CAACC,KAAK,CAACH,KAAK,CAAC;AAChC,IAAA,IAAI,CAACC,MAAM,EAAE,MAAMA,MAAM;EAC1B,CAAC,CAAC,OAAOG,GAAG,EAAE;AACb,IAAA,OAAO,KAAK;AACb,EAAA;AAEA,EAAA,OAAO,IAAI;AACZ;;;;"}

package/dist/esm/utils/isImageUri/index.js

@@ -0,0 +1,19 @@
+/**
+ * Checks if a passed image string is an image URI
+ *
+ * @param {string} image - the image string being tested
+ * @returns {boolean} - if the image is an image URI
+ */
+var isImageUri = image => {
+  try {
+    if (typeof image !== 'string') return false;
+    // eslint-disable-next-line no-new
+    new URL(image);
+  } catch (err) {
+    return false;
+  }
+  return true;
+};
+
+export { isImageUri };
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/isImageUri/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/utils/isImageUri/index.ts"],"sourcesContent":["/**\n * Checks if a passed image string is an image URI\n *\n * @param {string} image - the image string being tested\n * @returns {boolean} - if the image is an image URI\n */\nexport const isImageUri = (image: string): image is string => {\n\ttry {\n\t\tif (typeof image !== 'string') return false;\n\t\t// eslint-disable-next-line no-new\n\t\tnew URL(image);\n\t} catch (err) {\n\t\treturn false;\n\t}\n\n\treturn true;\n};\n"],"names":["isImageUri","image","URL","err"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,UAAU,GAAIC,KAAa,IAAsB;EAC7D,IAAI;AACH,IAAA,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE,OAAO,KAAK;AAC3C;IACA,IAAIC,GAAG,CAACD,KAAK,CAAC;EACf,CAAC,CAAC,OAAOE,GAAG,EAAE;AACb,IAAA,OAAO,KAAK;AACb,EAAA;AAEA,EAAA,OAAO,IAAI;AACZ;;;;"}

package/dist/esm/utils/isObject/isObject.js

@@ -0,0 +1,22 @@
+/**
+ * Item is passed to the `isObject` function.
+ * Since we want to be able to check if anything is an object, we allow
+ * anything to be passed to the function.
+ */
+
+/**
+ * Tests that a variable is actually an object and not an array  or null
+ * which can mistakenly be flagged as an object
+ *
+ * @param {Item} item - variable to tests
+ * @returns {boolean} - value if item is actually an Object
+ */
+var isObject = item => {
+  if (item && Array.isArray(item)) {
+    return false;
+  }
+  return item instanceof Object;
+};
+
+export { isObject };
+//# sourceMappingURL=isObject.js.map

package/dist/esm/utils/isObject/isObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObject.js","sources":["../../../../src/utils/isObject/isObject.ts"],"sourcesContent":["/**\n * Item is passed to the `isObject` function.\n * Since we want to be able to check if anything is an object, we allow\n * anything to be passed to the function.\n */\nexport type Item = unknown;\n\n/**\n * Tests that a variable is actually an object and not an array  or null\n * which can mistakenly be flagged as an object\n *\n * @param {Item} item - variable to tests\n * @returns {boolean} - value if item is actually an Object\n */\nexport const isObject = (item: Item): boolean => {\n\tif (item && Array.isArray(item)) {\n\t\treturn false;\n\t}\n\n\treturn item instanceof Object;\n};\n"],"names":["isObject","item","Array","isArray","Object"],"mappings":"AAAA;AACA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,QAAQ,GAAIC,IAAU,IAAc;EAChD,IAAIA,IAAI,IAAIC,KAAK,CAACC,OAAO,CAACF,IAAI,CAAC,EAAE;AAChC,IAAA,OAAO,KAAK;AACb,EAAA;EAEA,OAAOA,IAAI,YAAYG,MAAM;AAC9B;;;;"}

package/dist/esm/utils/isTouch/index.js

@@ -0,0 +1,11 @@
+/**
+ * Check if the device is a touch device
+ *
+ * @returns {boolean} - True if the device is a touch device
+ */
+var isTouchDevice = () => {
+  return 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+};
+
+export { isTouchDevice };
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/isTouch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/utils/isTouch/index.ts"],"sourcesContent":["/**\n * Check if the device is a touch device\n *\n * @returns {boolean} - True if the device is a touch device\n */\nexport const isTouchDevice = (): boolean => {\n\treturn 'ontouchstart' in window || navigator.maxTouchPoints > 0;\n};\n"],"names":["isTouchDevice","window","navigator","maxTouchPoints"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACO,IAAMA,aAAa,GAAGA,MAAe;EAC3C,OAAO,cAAc,IAAIC,MAAM,IAAIC,SAAS,CAACC,cAAc,GAAG,CAAC;AAChE;;;;"}

package/dist/esm/utils/layers/index.js

@@ -0,0 +1,61 @@
+/* eslint-disable sort-keys */
+/**
+ * References to the different portal layers
+ */
+var PORTAL_LAYERS = {
+  ROOT: {
+    name: 'mrl-root-portal',
+    zIndex: 50000
+  },
+  TOAST: {
+    name: 'mrl-toast-portal',
+    zIndex: 50001
+  },
+  MENU: {
+    name: 'mrl-menu-portal',
+    zIndex: 50002
+  },
+  POPOVER: {
+    name: 'mrl-popover-portal',
+    zIndex: 50003
+  },
+  POPOVER_MENU: {
+    name: 'mrl-popover-menu-portal',
+    zIndex: 50004
+  },
+  CALLOUT: {
+    name: 'mrl-callout-portal',
+    zIndex: 50004
+  },
+  MODAL: {
+    name: 'mrl-modal',
+    zIndex: 50005
+  },
+  SELECT: {
+    name: 'mrl-select-portal',
+    zIndex: 50006
+  },
+  TOOLTIP: {
+    name: 'mrl-tooltip-portal',
+    zIndex: 50007
+  },
+  TOP: {
+    name: 'mrl-top-portal',
+    zIndex: 50008
+  }
+};
+
+/**
+ * Get the current portal layer based on the provided element
+ *
+ * @param element - the element to check for the closest portal layer
+ * @returns the portal layer id
+ */
+var getCurrentPortalLayer = element => {
+  if (!element) return null;
+  var closestWithDataLayerId = element.closest('[data-layer-id]');
+  return closestWithDataLayerId ? closestWithDataLayerId.getAttribute('data-layer-id') : null;
+};
+
+export { PORTAL_LAYERS, getCurrentPortalLayer };
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/layers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/utils/layers/index.ts"],"sourcesContent":["/* eslint-disable sort-keys */\n/**\n * References to the different portal layers\n */\nexport const PORTAL_LAYERS = {\n\tROOT: { name: 'mrl-root-portal', zIndex: 50000 },\n\tTOAST: { name: 'mrl-toast-portal', zIndex: 50001 },\n\tMENU: { name: 'mrl-menu-portal', zIndex: 50002 },\n\tPOPOVER: { name: 'mrl-popover-portal', zIndex: 50003 },\n\tPOPOVER_MENU: { name: 'mrl-popover-menu-portal', zIndex: 50004 },\n\tCALLOUT: { name: 'mrl-callout-portal', zIndex: 50004 },\n\tMODAL: { name: 'mrl-modal', zIndex: 50005 },\n\tSELECT: { name: 'mrl-select-portal', zIndex: 50006 },\n\tTOOLTIP: { name: 'mrl-tooltip-portal', zIndex: 50007 },\n\tTOP: { name: 'mrl-top-portal', zIndex: 50008 }\n} as const;\n\n/**\n * Get the current portal layer based on the provided element\n *\n * @param element - the element to check for the closest portal layer\n * @returns the portal layer id\n */\nexport const getCurrentPortalLayer = (element: HTMLElement): string | null => {\n\tif (!element) return null;\n\n\tconst closestWithDataLayerId = element.closest('[data-layer-id]');\n\treturn closestWithDataLayerId ? closestWithDataLayerId.getAttribute('data-layer-id') : null;\n};\n"],"names":["PORTAL_LAYERS","ROOT","name","zIndex","TOAST","MENU","POPOVER","POPOVER_MENU","CALLOUT","MODAL","SELECT","TOOLTIP","TOP","getCurrentPortalLayer","element","closestWithDataLayerId","closest","getAttribute"],"mappings":"AAAA;AACA;AACA;AACA;AACO,IAAMA,aAAa,GAAG;AAC5BC,EAAAA,IAAI,EAAE;AAAEC,IAAAA,IAAI,EAAE,iBAAiB;AAAEC,IAAAA,MAAM,EAAE;GAAO;AAChDC,EAAAA,KAAK,EAAE;AAAEF,IAAAA,IAAI,EAAE,kBAAkB;AAAEC,IAAAA,MAAM,EAAE;GAAO;AAClDE,EAAAA,IAAI,EAAE;AAAEH,IAAAA,IAAI,EAAE,iBAAiB;AAAEC,IAAAA,MAAM,EAAE;GAAO;AAChDG,EAAAA,OAAO,EAAE;AAAEJ,IAAAA,IAAI,EAAE,oBAAoB;AAAEC,IAAAA,MAAM,EAAE;GAAO;AACtDI,EAAAA,YAAY,EAAE;AAAEL,IAAAA,IAAI,EAAE,yBAAyB;AAAEC,IAAAA,MAAM,EAAE;GAAO;AAChEK,EAAAA,OAAO,EAAE;AAAEN,IAAAA,IAAI,EAAE,oBAAoB;AAAEC,IAAAA,MAAM,EAAE;GAAO;AACtDM,EAAAA,KAAK,EAAE;AAAEP,IAAAA,IAAI,EAAE,WAAW;AAAEC,IAAAA,MAAM,EAAE;GAAO;AAC3CO,EAAAA,MAAM,EAAE;AAAER,IAAAA,IAAI,EAAE,mBAAmB;AAAEC,IAAAA,MAAM,EAAE;GAAO;AACpDQ,EAAAA,OAAO,EAAE;AAAET,IAAAA,IAAI,EAAE,oBAAoB;AAAEC,IAAAA,MAAM,EAAE;GAAO;AACtDS,EAAAA,GAAG,EAAE;AAAEV,IAAAA,IAAI,EAAE,gBAAgB;AAAEC,IAAAA,MAAM,EAAE;AAAM;AAC9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMU,qBAAqB,GAAIC,OAAoB,IAAoB;AAC7E,EAAA,IAAI,CAACA,OAAO,EAAE,OAAO,IAAI;AAEzB,EAAA,IAAMC,sBAAsB,GAAGD,OAAO,CAACE,OAAO,CAAC,iBAAiB,CAAC;EACjE,OAAOD,sBAAsB,GAAGA,sBAAsB,CAACE,YAAY,CAAC,eAAe,CAAC,GAAG,IAAI;AAC5F;;;;"}

package/dist/esm/utils/noop/index.js

@@ -0,0 +1,11 @@
+/**
+ * No operation function to be used as a default callback.
+ *
+ * Example usage: in tests where there is a required handler, but we do not want to do anything.
+ * Better than passing a console log which clutters up our test output.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+var noop = () => {};
+
+export { noop };
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/noop/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/utils/noop/index.ts"],"sourcesContent":["/**\n * No operation function to be used as a default callback.\n *\n * Example usage: in tests where there is a required handler, but we do not want to do anything.\n * Better than passing a console log which clutters up our test output.\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport const noop = (): void => {};\n"],"names":["noop"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;IACaA,IAAI,GAAGA,MAAY,CAAC;;;;"}

package/dist/esm/utils/preventDefault/preventDefault.js

@@ -0,0 +1,12 @@
+/**
+ * Prevent default on event
+ *
+ * @param e - The event
+ */
+var preventDefault = e => {
+  e.preventDefault();
+  e.stopPropagation();
+};
+
+export { preventDefault };
+//# sourceMappingURL=preventDefault.js.map

package/dist/esm/utils/preventDefault/preventDefault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preventDefault.js","sources":["../../../../src/utils/preventDefault/preventDefault.ts"],"sourcesContent":["/**\n * Prevent default on event\n *\n * @param e - The event\n */\nexport const preventDefault = (\n\te: React.MouseEvent | React.KeyboardEvent | MouseEvent | KeyboardEvent\n): void => {\n\te.preventDefault();\n\te.stopPropagation();\n};\n"],"names":["preventDefault","e","stopPropagation"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACO,IAAMA,cAAc,GAC1BC,CAAsE,IAC5D;EACVA,CAAC,CAACD,cAAc,EAAE;EAClBC,CAAC,CAACC,eAAe,EAAE;AACpB;;;;"}

package/dist/esm/utils/setAttributes/setAttributes.js

@@ -0,0 +1,102 @@
+import { objectSpread2 as _objectSpread2 } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import classnames from 'classnames';
+import { isObject } from '../isObject/isObject.js';
+
+// We don't necessarily know what a user passes to any given key in the attributes object
+// so allowing "any" here will prevent unexpected TS failures
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * Parse a string of attributes into a JSON object
+ *
+ * @param {string} attributes - the custom attributes passed to a component
+ * @returns {AttrsObject} - an object of attributes
+ */
+var parseAttributes = attributes => {
+  try {
+    return JSON.parse(attributes);
+  } catch (error) {
+    console.error('The attrs property is not properly-formatted JSON:');
+    console.error(attributes);
+    console.error(error);
+    return error;
+  }
+};
+
+/**
+ * Object that contains all of the classes that can be applied to an element
+ * and a condition that determines if that instance should have it
+ * applied or not. The structure is:
+ * "my-class": !theConditional
+ */
+
+/**
+ * Sets up a classObject to be used by the className prop
+ *
+ * @todo - 2563 - use setClasses across components
+ * @param {string} customClasses - custom classes to apply via the attrs prop
+ * @param {ClassObject} defaultClasses - design system component classes to apply
+ * @returns {ClassObject} - with all classes
+ */
+var setClasses = (customClasses, defaultClasses) => {
+  /**
+   * If a string is passed, we must parse it into a valid JSON object.
+   * Otherwise, we can assign the passed attributes directly to the returned object.
+   */
+  var parsedAttr = typeof customClasses === 'string' ? parseAttributes(customClasses) : customClasses;
+  if (parsedAttr && isObject(parsedAttr) && parsedAttr.class) {
+    return _objectSpread2({
+      ["".concat(parsedAttr.class)]: typeof parsedAttr.class !== 'undefined' && parsedAttr.class.length > 0
+    }, defaultClasses);
+  }
+  return defaultClasses;
+};
+
+/**
+ * Set an object of attributes to be used in a given component.
+ *
+ * @param {AttrsObject} attributes - The custom attributes passed to the component
+ * @param {AttrsObject} defaults - An optional object of the default attributes of a component
+ * @param {string} className - Default classes to apply to the component
+ *
+ * Use when applying attributes such as a className directly to a react component.
+ * @returns {AttrsObject} - An object of component attributes
+ */
+var setAttributes = function setAttributes(attributes) {
+  var defaults = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var className = arguments.length > 2 ? arguments[2] : undefined;
+  /**
+   * If a string is passed, we must parse it into a valid JSON object.
+   * Otherwise, we can assign the passed attributes directly to the returned object.
+   */
+  var customAttributes = typeof attributes === 'string' ? parseAttributes(attributes) : attributes;
+  if (customAttributes) {
+    /**
+     * Assign the defaults and the passed attributes to a new object
+     * to ensure that one attributes object without duplicated keys
+     * can be passed to the component.
+     */
+
+    // Applies className instead of class when forReact is true
+    return Object.assign({}, defaults, customAttributes, {
+      className: classnames(className, customAttributes.className)
+    });
+  }
+  return {};
+};
+var lastId = 0;
+
+/**
+ *  Generates unique identifier
+ *
+ * @param {string} prefix  - prefix for identifier
+ * @returns {string} - prefixed unique identifier
+ */
+var getUniqueId = function getUniqueId() {
+  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'mrl';
+  lastId++;
+  return "".concat(prefix, "-").concat(lastId);
+};
+
+export { getUniqueId, setAttributes, setClasses };
+//# sourceMappingURL=setAttributes.js.map

package/dist/esm/utils/setAttributes/setAttributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setAttributes.js","sources":["../../../../src/utils/setAttributes/setAttributes.ts"],"sourcesContent":["import cn from 'classnames';\nimport { isObject } from '../isObject';\n\n// We don't necessarily know what a user passes to any given key in the attributes object\n// so allowing \"any\" here will prevent unexpected TS failures\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AttrsObject = Record<string, any>;\n\n/**\n * Parse a string of attributes into a JSON object\n *\n * @param {string} attributes - the custom attributes passed to a component\n * @returns {AttrsObject} - an object of attributes\n */\nconst parseAttributes = (attributes: string): AttrsObject => {\n\ttry {\n\t\treturn JSON.parse(attributes);\n\t} catch (error) {\n\t\tconsole.error('The attrs property is not properly-formatted JSON:');\n\t\tconsole.error(attributes);\n\t\tconsole.error(error);\n\t\treturn error as AttrsObject;\n\t}\n};\n\n/**\n * Object that contains all of the classes that can be applied to an element\n * and a condition that determines if that instance should have it\n * applied or not. The structure is:\n * \"my-class\": !theConditional\n */\nexport type ClassObject = Record<string, boolean>;\n\n/**\n * Sets up a classObject to be used by the className prop\n *\n * @todo - 2563 - use setClasses across components\n * @param {string} customClasses - custom classes to apply via the attrs prop\n * @param {ClassObject} defaultClasses - design system component classes to apply\n * @returns {ClassObject} - with all classes\n */\nexport const setClasses = (\n\tcustomClasses: AttrsObject | undefined,\n\tdefaultClasses: ClassObject\n): ClassObject => {\n\t/**\n\t * If a string is passed, we must parse it into a valid JSON object.\n\t * Otherwise, we can assign the passed attributes directly to the returned object.\n\t */\n\tconst parsedAttr =\n\t\ttypeof customClasses === 'string' ? parseAttributes(customClasses) : customClasses;\n\n\tif (parsedAttr && isObject(parsedAttr) && parsedAttr.class) {\n\t\treturn {\n\t\t\t[`${parsedAttr.class}`]:\n\t\t\t\ttypeof parsedAttr.class !== 'undefined' && parsedAttr.class.length > 0,\n\t\t\t...defaultClasses\n\t\t};\n\t}\n\n\treturn defaultClasses;\n};\n\n/**\n * Set an object of attributes to be used in a given component.\n *\n * @param {AttrsObject} attributes - The custom attributes passed to the component\n * @param {AttrsObject} defaults - An optional object of the default attributes of a component\n * @param {string} className - Default classes to apply to the component\n *\n * Use when applying attributes such as a className directly to a react component.\n * @returns {AttrsObject} - An object of component attributes\n */\nexport const setAttributes = (\n\tattributes: AttrsObject | undefined,\n\tdefaults: AttrsObject = {},\n\tclassName?: string\n): AttrsObject => {\n\t/**\n\t * If a string is passed, we must parse it into a valid JSON object.\n\t * Otherwise, we can assign the passed attributes directly to the returned object.\n\t */\n\tconst customAttributes =\n\t\ttypeof attributes === 'string' ? parseAttributes(attributes) : attributes;\n\n\tif (customAttributes) {\n\t\t/**\n\t\t * Assign the defaults and the passed attributes to a new object\n\t\t * to ensure that one attributes object without duplicated keys\n\t\t * can be passed to the component.\n\t\t */\n\n\t\t// Applies className instead of class when forReact is true\n\t\treturn Object.assign({}, defaults, customAttributes, {\n\t\t\tclassName: cn(className, customAttributes.className)\n\t\t});\n\t}\n\n\treturn {};\n};\n\nlet lastId = 0;\n\n/**\n *  Generates unique identifier\n *\n * @param {string} prefix  - prefix for identifier\n * @returns {string} - prefixed unique identifier\n */\nexport const getUniqueId = (prefix = 'mrl'): string => {\n\tlastId++;\n\treturn `${prefix}-${lastId}`;\n};\n"],"names":["parseAttributes","attributes","JSON","parse","error","console","setClasses","customClasses","defaultClasses","parsedAttr","isObject","class","_objectSpread","concat","length","setAttributes","defaults","arguments","undefined","className","customAttributes","Object","assign","cn","lastId","getUniqueId","prefix"],"mappings":";;;;AAGA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMA,eAAe,GAAIC,UAAkB,IAAkB;EAC5D,IAAI;AACH,IAAA,OAAOC,IAAI,CAACC,KAAK,CAACF,UAAU,CAAC;EAC9B,CAAC,CAAC,OAAOG,KAAK,EAAE;AACfC,IAAAA,OAAO,CAACD,KAAK,CAAC,oDAAoD,CAAC;AACnEC,IAAAA,OAAO,CAACD,KAAK,CAACH,UAAU,CAAC;AACzBI,IAAAA,OAAO,CAACD,KAAK,CAACA,KAAK,CAAC;AACpB,IAAA,OAAOA,KAAK;AACb,EAAA;AACD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IACaE,UAAU,GAAGA,CACzBC,aAAsC,EACtCC,cAA2B,KACV;AACjB;AACD;AACA;AACA;AACC,EAAA,IAAMC,UAAU,GACf,OAAOF,aAAa,KAAK,QAAQ,GAAGP,eAAe,CAACO,aAAa,CAAC,GAAGA,aAAa;EAEnF,IAAIE,UAAU,IAAIC,QAAQ,CAACD,UAAU,CAAC,IAAIA,UAAU,CAACE,KAAK,EAAE;AAC3D,IAAA,OAAAC,cAAA,CAAA;AACC,MAAA,CAAA,EAAA,CAAAC,MAAA,CAAIJ,UAAU,CAACE,KAAK,CAAA,GACnB,OAAOF,UAAU,CAACE,KAAK,KAAK,WAAW,IAAIF,UAAU,CAACE,KAAK,CAACG,MAAM,GAAG;AAAC,KAAA,EACpEN,cAAc,CAAA;AAEnB,EAAA;AAEA,EAAA,OAAOA,cAAc;AACtB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IACaO,aAAa,GAAG,SAAhBA,aAAaA,CACzBd,UAAmC,EAGlB;AAAA,EAAA,IAFjBe,QAAqB,GAAAC,SAAA,CAAAH,MAAA,GAAA,CAAA,IAAAG,SAAA,CAAA,CAAA,CAAA,KAAAC,SAAA,GAAAD,SAAA,CAAA,CAAA,CAAA,GAAG,EAAE;EAAA,IAC1BE,SAAkB,GAAAF,SAAA,CAAAH,MAAA,GAAA,CAAA,GAAAG,SAAA,MAAAC,SAAA;AAElB;AACD;AACA;AACA;AACC,EAAA,IAAME,gBAAgB,GACrB,OAAOnB,UAAU,KAAK,QAAQ,GAAGD,eAAe,CAACC,UAAU,CAAC,GAAGA,UAAU;AAE1E,EAAA,IAAImB,gBAAgB,EAAE;AACrB;AACF;AACA;AACA;AACA;;AAEE;IACA,OAAOC,MAAM,CAACC,MAAM,CAAC,EAAE,EAAEN,QAAQ,EAAEI,gBAAgB,EAAE;AACpDD,MAAAA,SAAS,EAAEI,UAAE,CAACJ,SAAS,EAAEC,gBAAgB,CAACD,SAAS;AACpD,KAAC,CAAC;AACH,EAAA;AAEA,EAAA,OAAO,EAAE;AACV;AAEA,IAAIK,MAAM,GAAG,CAAC;;AAEd;AACA;AACA;AACA;AACA;AACA;IACaC,WAAW,GAAG,SAAdA,WAAWA,GAA+B;AAAA,EAAA,IAA3BC,MAAM,GAAAT,SAAA,CAAAH,MAAA,GAAA,CAAA,IAAAG,SAAA,CAAA,CAAA,CAAA,KAAAC,SAAA,GAAAD,SAAA,CAAA,CAAA,CAAA,GAAG,KAAK;AACzCO,EAAAA,MAAM,EAAE;AACR,EAAA,OAAA,EAAA,CAAAX,MAAA,CAAUa,MAAM,EAAA,GAAA,CAAA,CAAAb,MAAA,CAAIW,MAAM,CAAA;AAC3B;;;;"}

package/dist/esm/utils/trapFocus/index.js

@@ -0,0 +1,155 @@
+import { slicedToArray as _slicedToArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
+
+var A_SELECTOR = 'a[href]:not([disabled])';
+var BUTTON_SELECTOR = 'button:not([disabled]):not([tabindex="-1"])';
+var TEXTAREA_SELECTOR = 'textarea:not([disabled])';
+var INPUT = 'input:not([type="hidden"]):not([disabled])';
+var SEARCH_INPUT = 'input[type="search"]:not([disabled])';
+var SELECT_SELECTOR = 'select:not([disabled])';
+var TAB_INDEX = '[tabindex]:not([tabindex="-1"]):not([disabled])';
+var WEB_COMPONENTS = 'mrl-icon-button:not([tabindex="-1"])';
+var TABBABLE_CONTENT_AREAS = 'div[tabindex="0"]';
+var FOCUSABLE_ELEMENTS_SELECTOR = [A_SELECTOR, BUTTON_SELECTOR, TEXTAREA_SELECTOR, INPUT, SEARCH_INPUT, SELECT_SELECTOR, TAB_INDEX, WEB_COMPONENTS, TABBABLE_CONTENT_AREAS].join(', ');
+
+/**
+ * Focus trap logic
+ * @param {HTMLElement} element - The component props.
+ * @returns {HTMLElement[]} - The focusable elements inside the element.
+ */
+var getFocusableElementsInsideElement = element => {
+  var focusableElements = Array.from(element.querySelectorAll(FOCUSABLE_ELEMENTS_SELECTOR)).filter(n => n instanceof HTMLElement);
+
+  // If no focusable elements are found, check if the container can be focused
+  if (focusableElements.length === 0) {
+    // Check if the element has a -1 tabindex, if it doesn't let's add it so it can be focused
+    if (!element.hasAttribute('tabindex') || element.tabIndex < 0) {
+      element.setAttribute('tabindex', '-1');
+    }
+    focusableElements.push(element);
+  }
+  return focusableElements;
+};
+
+/**
+ * Gets the first element with the data-autofocus="true" attribute within the container element
+ * @param {HTMLElement} containerElement - container element
+ * @returns {HTMLElement | undefined} - the first element that has autofocus="true" or undefined
+ */
+var getElementWithAutofocus = containerElement => {
+  var focusableElements = getFocusableElementsInsideElement(containerElement);
+  return focusableElements.find(el => {
+    return el.getAttribute('data-autofocus') === 'true';
+  });
+};
+
+/**
+ * Returns if an element is a radio element
+ * @param {Element} el - The element
+ * @returns {HTMLInputElement} Returns true if the element is a radio
+ */
+var isElementRadioButton = el => {
+  return el.tagName === 'INPUT' && el.type === 'radio';
+};
+
+/**
+ * Traps focus inside of an element
+ * Adapted from https://hidde.blog/using-javascript-to-trap-focus-in-an-element/
+ * @param {HTMLElement} element // Element to trap focus in
+ * @param {boolean} disableAutofocus // Whether to disable autofocus
+ * @returns {Function}          // Cleanup function to be run when component is
+ *                              // removed from the DOM
+ */
+var trapFocus = function trapFocus(element) {
+  var disableAutofocus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var previouslyFocusedEl = document.activeElement;
+  var mutationObserver = new MutationObserver(() => {
+    var _getFocusableElements = getFocusableElementsInsideElement(element),
+      _getFocusableElements2 = _slicedToArray(_getFocusableElements, 1),
+      firstFocusableElement = _getFocusableElements2[0];
+
+    // The previously focused element was removed from the DOM
+    if (!document.activeElement) {
+      firstFocusableElement.focus();
+    }
+  });
+  var tabListener = e => {
+    if (e.key !== 'Tab') {
+      return;
+    }
+    var focusableElements = getFocusableElementsInsideElement(element);
+    var firstFocusableElement = focusableElements[0];
+    var lastFocusableElement = focusableElements[focusableElements.length - 1];
+    if (e.shiftKey) {
+      // If the activeElement is a radio button and shares the same 'name' attribute as the firstFocusableElement
+      if (document.activeElement && isElementRadioButton(document.activeElement) && isElementRadioButton(firstFocusableElement) && document.activeElement.name === firstFocusableElement.name) {
+        lastFocusableElement.focus();
+        e.preventDefault();
+        return;
+      }
+
+      // Reverse in tab order, but we're at the beginning of the list
+      if (document.activeElement === firstFocusableElement) {
+        lastFocusableElement.focus();
+        e.preventDefault();
+        return;
+      }
+    } else if (document.activeElement === lastFocusableElement) {
+      // Forward in tab order, but we're at the end of the list
+      firstFocusableElement.focus();
+      e.preventDefault();
+    }
+  };
+  mutationObserver.observe(element, {
+    childList: true,
+    subtree: true
+  });
+  element.addEventListener('keydown', tabListener);
+
+  /**
+   * In the event an element has its tabindex set after component mounting has completed, we need
+   * to allow the callstack to clear to ensure it's properly set before we can focus the first element.
+   */
+  setTimeout(() => {
+    var elementWithAutofocus = getElementWithAutofocus(element);
+    if (elementWithAutofocus) {
+      elementWithAutofocus.focus();
+      return;
+    }
+    if (!disableAutofocus) {
+      var _getFocusableElements3 = getFocusableElementsInsideElement(element),
+        _getFocusableElements4 = _slicedToArray(_getFocusableElements3, 1),
+        firstFocusableElement = _getFocusableElements4[0];
+      firstFocusableElement === null || firstFocusableElement === void 0 ? void 0 : firstFocusableElement.focus();
+    }
+  }, 20);
+  return () => {
+    element.removeEventListener('keydown', tabListener);
+    mutationObserver.disconnect();
+
+    /**
+     * Restore focus to element that was in focus before the focus trap was activated
+     *
+     * Conditions to move focus:
+     * - If it is still inside the trap, or effectively "lost"
+     * - If focus has been intentionally moved outside, do nothing
+     */
+    var active = document.activeElement;
+    var focusIsInside = !!active && element.contains(active);
+    var focusIsLost = !active || active === document.body;
+    if (focusIsInside || focusIsLost) {
+      var body = document.body;
+
+      // get data-focus-item attribute from body
+      var focusItemId = body.dataset.focusItem;
+      var focusItemEl = focusItemId ? document.getElementById(focusItemId) : null;
+      var focusTarget = focusItemEl !== null && focusItemEl !== void 0 ? focusItemEl : previouslyFocusedEl;
+      if (focusTarget instanceof HTMLElement) {
+        focusTarget.focus();
+      }
+      delete body.dataset.focusItem;
+    }
+  };
+};
+
+export { FOCUSABLE_ELEMENTS_SELECTOR, getElementWithAutofocus, getFocusableElementsInsideElement, trapFocus };
+//# sourceMappingURL=index.js.map