@esri/solutions-components 0.8.1 → 0.8.3

package/dist/components/filter2.js

@@ -4,6 +4,7 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { d as debounce } from './lodash.js';
 import { f as filter } from './filter.js';
 import { c as connectInteractive, u as updateHostInteraction, d as disconnectInteractive, I as InteractiveContainer } from './interactive.js';
 import { s as setUpLoadableComponent, a as setComponentLoaded, c as componentFocusable } from './loadable.js';
@@ -12,7 +13,6 @@ import { u as updateMessages, s as setUpMessages, c as connectMessages, d as dis
 import { d as defineCustomElement$3 } from './icon.js';
 import { d as defineCustomElement$2 } from './input.js';
 import { d as defineCustomElement$1 } from './progress.js';
-import { d as debounce } from './debounce.js';
 
 /*!
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
@@ -216,6 +216,6 @@ function defineCustomElement() {
             break;
     } });
 }
-defineCustomElement();
+defineCustomElement(Filter);
 
 export { Filter as F, defineCustomElement as d };

package/dist/components/floating-ui.js

@@ -4,8 +4,8 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 import { Build } from '@stencil/core/internal/client';
+import { d as debounce } from './lodash.js';
 import { g as getElementDir } from './dom.js';
-import { d as debounce } from './debounce.js';
 
 /**
  * Custom positioning reference element.
@@ -14,7 +14,7 @@ import { d as debounce } from './debounce.js';
 
 const sides = ['top', 'right', 'bottom', 'left'];
 const alignments = ['start', 'end'];
-const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+const placements$1 = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
 const min = Math.min;
 const max = Math.max;
 const round = Math.round;
@@ -462,14 +462,14 @@ const autoPlacement$1 = function (options) {
       const {
         crossAxis = false,
         alignment,
-        allowedPlacements = placements,
+        allowedPlacements = placements$1,
         autoAlignment = true,
         ...detectOverflowOptions
       } = evaluate(options, state);
-      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
+      const placements$1$1 = alignment !== undefined || allowedPlacements === placements$1 ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
       const overflow = await detectOverflow(state, detectOverflowOptions);
       const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
-      const currentPlacement = placements$1[currentIndex];
+      const currentPlacement = placements$1$1[currentIndex];
       if (currentPlacement == null) {
         return {};
       }
@@ -479,7 +479,7 @@ const autoPlacement$1 = function (options) {
       if (placement !== currentPlacement) {
         return {
           reset: {
-            placement: placements$1[0]
+            placement: placements$1$1[0]
           }
         };
       }
@@ -488,7 +488,7 @@ const autoPlacement$1 = function (options) {
         placement: currentPlacement,
         overflows: currentOverflows
       }];
-      const nextPlacement = placements$1[currentIndex + 1];
+      const nextPlacement = placements$1$1[currentIndex + 1];
 
       // There are more placements to check.
       if (nextPlacement) {
@@ -715,6 +715,137 @@ const hide$1 = function (options) {
   };
 };
 
+function getBoundingRect(rects) {
+  const minX = min(...rects.map(rect => rect.left));
+  const minY = min(...rects.map(rect => rect.top));
+  const maxX = max(...rects.map(rect => rect.right));
+  const maxY = max(...rects.map(rect => rect.bottom));
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function getRectsByLine(rects) {
+  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);
+  const groups = [];
+  let prevRect = null;
+  for (let i = 0; i < sortedRects.length; i++) {
+    const rect = sortedRects[i];
+    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {
+      groups.push([rect]);
+    } else {
+      groups[groups.length - 1].push(rect);
+    }
+    prevRect = rect;
+  }
+  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));
+}
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+const inline$1 = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'inline',
+    options,
+    async fn(state) {
+      const {
+        placement,
+        elements,
+        rects,
+        platform,
+        strategy
+      } = state;
+      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
+      // ClientRect's bounds, despite the event listener being triggered. A
+      // padding of 2 seems to handle this issue.
+      const {
+        padding = 2,
+        x,
+        y
+      } = evaluate(options, state);
+      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);
+      const clientRects = getRectsByLine(nativeClientRects);
+      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));
+      const paddingObject = getPaddingObject(padding);
+      function getBoundingClientRect() {
+        // There are two rects and they are disjoined.
+        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {
+          // Find the first rect in which the point is fully inside.
+          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;
+        }
+
+        // There are 2 or more connected rects.
+        if (clientRects.length >= 2) {
+          if (getSideAxis(placement) === 'y') {
+            const firstRect = clientRects[0];
+            const lastRect = clientRects[clientRects.length - 1];
+            const isTop = getSide(placement) === 'top';
+            const top = firstRect.top;
+            const bottom = lastRect.bottom;
+            const left = isTop ? firstRect.left : lastRect.left;
+            const right = isTop ? firstRect.right : lastRect.right;
+            const width = right - left;
+            const height = bottom - top;
+            return {
+              top,
+              bottom,
+              left,
+              right,
+              width,
+              height,
+              x: left,
+              y: top
+            };
+          }
+          const isLeftSide = getSide(placement) === 'left';
+          const maxRight = max(...clientRects.map(rect => rect.right));
+          const minLeft = min(...clientRects.map(rect => rect.left));
+          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
+          const top = measureRects[0].top;
+          const bottom = measureRects[measureRects.length - 1].bottom;
+          const left = minLeft;
+          const right = maxRight;
+          const width = right - left;
+          const height = bottom - top;
+          return {
+            top,
+            bottom,
+            left,
+            right,
+            width,
+            height,
+            x: left,
+            y: top
+          };
+        }
+        return fallback;
+      }
+      const resetRects = await platform.getElementRects({
+        reference: {
+          getBoundingClientRect
+        },
+        floating: elements.floating,
+        strategy
+      });
+      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {
+        return {
+          reset: {
+            rects: resetRects
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
+
 // For type backwards-compatibility, the `OffsetOptions` type was also
 // Derivable.
 
@@ -871,6 +1002,156 @@ const shift$1 = function (options) {
     }
   };
 };
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+const limitShift$1 = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    options,
+    fn(state) {
+      const {
+        x,
+        y,
+        placement,
+        rects,
+        middlewareData
+      } = state;
+      const {
+        offset = 0,
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const crossAxis = getSideAxis(placement);
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      const rawOffset = evaluate(offset, state);
+      const computedOffset = typeof rawOffset === 'number' ? {
+        mainAxis: rawOffset,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...rawOffset
+      };
+      if (checkMainAxis) {
+        const len = mainAxis === 'y' ? 'height' : 'width';
+        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+        if (mainAxisCoord < limitMin) {
+          mainAxisCoord = limitMin;
+        } else if (mainAxisCoord > limitMax) {
+          mainAxisCoord = limitMax;
+        }
+      }
+      if (checkCrossAxis) {
+        var _middlewareData$offse, _middlewareData$offse2;
+        const len = mainAxis === 'y' ? 'width' : 'height';
+        const isOriginSide = ['top', 'left'].includes(getSide(placement));
+        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+        if (crossAxisCoord < limitMin) {
+          crossAxisCoord = limitMin;
+        } else if (crossAxisCoord > limitMax) {
+          crossAxisCoord = limitMax;
+        }
+      }
+      return {
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      };
+    }
+  };
+};
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+const size$1 = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'size',
+    options,
+    async fn(state) {
+      const {
+        placement,
+        rects,
+        platform,
+        elements
+      } = state;
+      const {
+        apply = () => {},
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const side = getSide(placement);
+      const alignment = getAlignment(placement);
+      const isYAxis = getSideAxis(placement) === 'y';
+      const {
+        width,
+        height
+      } = rects.floating;
+      let heightSide;
+      let widthSide;
+      if (side === 'top' || side === 'bottom') {
+        heightSide = side;
+        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';
+      } else {
+        widthSide = side;
+        heightSide = alignment === 'end' ? 'top' : 'bottom';
+      }
+      const overflowAvailableHeight = height - overflow[heightSide];
+      const overflowAvailableWidth = width - overflow[widthSide];
+      const noShift = !state.middlewareData.shift;
+      let availableHeight = overflowAvailableHeight;
+      let availableWidth = overflowAvailableWidth;
+      if (isYAxis) {
+        const maximumClippingWidth = width - overflow.left - overflow.right;
+        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
+      } else {
+        const maximumClippingHeight = height - overflow.top - overflow.bottom;
+        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
+      }
+      if (noShift && !alignment) {
+        const xMin = max(overflow.left, 0);
+        const xMax = max(overflow.right, 0);
+        const yMin = max(overflow.top, 0);
+        const yMax = max(overflow.bottom, 0);
+        if (isYAxis) {
+          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+        } else {
+          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+        }
+      }
+      await apply({
+        ...state,
+        availableWidth,
+        availableHeight
+      });
+      const nextDimensions = await platform.getDimensions(elements.floating);
+      if (width !== nextDimensions.width || height !== nextDimensions.height) {
+        return {
+          reset: {
+            rects: true
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
 
 function getNodeName(node) {
   if (isNode(node)) {
@@ -1598,6 +1879,14 @@ const shift = shift$1;
  */
 const flip = flip$1;
 
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+const size = size$1;
+
 /**
  * Provides data to hide the floating element in applicable situations, such as
  * when it is not in the same clipping context as the reference element.
@@ -1612,6 +1901,18 @@ const hide = hide$1;
  */
 const arrow = arrow$1;
 
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+const inline = inline$1;
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+const limitShift = limitShift$1;
+
 /**
  * Computes the `x` and `y` coordinates that will place the floating element
  * next to a given reference element.
@@ -1639,6 +1940,12 @@ const computePosition = (reference, floating, options) => {
 function offsetParent(element) {
     return offsetParentPolyfill(element);
 }
+function offsetTop(element) {
+    return offsetTopLeftPolyfill(element, 'offsetTop');
+}
+function offsetLeft(element) {
+    return offsetTopLeftPolyfill(element, 'offsetLeft');
+}
 function flatTreeParent(element) {
     if (element.assignedSlot) {
         return element.assignedSlot;
@@ -1648,6 +1955,17 @@ function flatTreeParent(element) {
     }
     return element.parentNode;
 }
+function ancestorTreeScopes(element) {
+    const scopes = new Set();
+    let currentScope = element.getRootNode();
+    while (currentScope) {
+        scopes.add(currentScope);
+        currentScope = currentScope.parentNode
+            ? currentScope.parentNode.getRootNode()
+            : null;
+    }
+    return scopes;
+}
 function offsetParentPolyfill(element) {
     // Do an initial walk to check for display:none ancestors.
     for (let ancestor = element; ancestor; ancestor = flatTreeParent(ancestor)) {
@@ -1676,6 +1994,16 @@ function offsetParentPolyfill(element) {
     }
     return null;
 }
+function offsetTopLeftPolyfill(element, offsetTopOrLeft) {
+    let value = element[offsetTopOrLeft];
+    let nextOffsetParent = offsetParentPolyfill(element);
+    const scopes = ancestorTreeScopes(element);
+    while (nextOffsetParent && !scopes.has(nextOffsetParent.getRootNode())) {
+        value -= nextOffsetParent[offsetTopOrLeft];
+        nextOffsetParent = offsetParentPolyfill(nextOffsetParent);
+    }
+    return value;
+}
 
 /*!
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
@@ -1789,6 +2117,32 @@ const placementDataAttribute = "data-placement";
  * Exported for testing purposes only
  */
 const repositionDebounceTimeout = 100;
+const placements = [
+    // auto placements
+    "auto",
+    "auto-start",
+    "auto-end",
+    // placements
+    "top",
+    "top-start",
+    "top-end",
+    "bottom",
+    "bottom-start",
+    "bottom-end",
+    "right",
+    "right-start",
+    "right-end",
+    "left",
+    "left-start",
+    "left-end",
+    // variation placements
+    "leading-start",
+    "leading",
+    "leading-end",
+    "trailing-end",
+    "trailing",
+    "trailing-start",
+];
 const effectivePlacements = [
     "top",
     "bottom",
@@ -1803,6 +2157,29 @@ const effectivePlacements = [
     "left-start",
     "left-end",
 ];
+const menuPlacements = ["top-start", "top", "top-end", "bottom-start", "bottom", "bottom-end"];
+const menuEffectivePlacements = [
+    "top-start",
+    "top",
+    "top-end",
+    "bottom-start",
+    "bottom",
+    "bottom-end",
+];
+const flipPlacements = [
+    "top",
+    "bottom",
+    "right",
+    "left",
+    "top-start",
+    "top-end",
+    "bottom-start",
+    "bottom-end",
+    "right-start",
+    "right-end",
+    "left-start",
+    "left-end",
+];
 const defaultMenuPlacement = "bottom-start";
 const FloatingCSS = {
     animation: "calcite-floating-ui-anim",

package/dist/components/floor-filter2.js

@@ -122,6 +122,6 @@ function defineCustomElement() {
             break;
     } });
 }
-defineCustomElement();
+defineCustomElement(FloorFilter);
 
 export { FloorFilter as F, defineCustomElement as d };

package/dist/components/flow-item.js

@@ -265,6 +265,6 @@ function defineCustomElement() {
             break;
     } });
 }
-defineCustomElement();
+defineCustomElement(FlowItem);
 
 export { FlowItem as F, defineCustomElement as d };

package/dist/components/flow.js

@@ -167,6 +167,6 @@ function defineCustomElement() {
             break;
     } });
 }
-defineCustomElement();
+defineCustomElement(Flow);
 
 export { Flow as F, defineCustomElement as d };

package/dist/components/focusTrapComponent.js

@@ -3,7 +3,7 @@
  * Licensed under the Apache License, Version 2.0
  * http://www.apache.org/licenses/LICENSE-2.0
  */
-import { l as tabbable, m as focusable, n as isTabbable, o as getTabIndex, p as isFocusable, f as focusElement, r as tabbableOptions } from './dom.js';
+import { l as isFocusable, m as tabbable, n as focusable, o as isTabbable, p as getTabIndex, f as focusElement, r as tabbableOptions } from './dom.js';
 
 /*!
 * focus-trap 7.5.4

package/dist/components/form.js

@@ -3,7 +3,7 @@
  * Licensed under the Apache License, Version 2.0
  * http://www.apache.org/licenses/LICENSE-2.0
  */
-import { q as queryElementRoots, c as closestElementCrossShadowBoundary } from './dom.js';
+import { c as closestElementCrossShadowBoundary, q as queryElementRoots } from './dom.js';
 import { h } from '@stencil/core/internal/client';
 
 /*!

package/dist/components/graph.js

@@ -240,6 +240,6 @@ function defineCustomElement() {
             break;
     } });
 }
-defineCustomElement();
+defineCustomElement(Graph);
 
 export { Graph as G, defineCustomElement as d };

package/dist/components/handle.js

@@ -233,6 +233,6 @@ function defineCustomElement() {
             break;
     } });
 }
-defineCustomElement();
+defineCustomElement(Handle);
 
 export { Handle as H, defineCustomElement as d };

package/dist/components/helpers.js

@@ -4,7 +4,7 @@
  * http://www.apache.org/licenses/LICENSE-2.0
  */
 import { l as loadModules } from './loadModules2.js';
-import { g as getMergedEffect, s as store, i as interactiveLegendState } from './store.js';
+import { i as interactiveLegendState, g as getMergedEffect, s as store } from './store.js';
 
 // data handling
 function activeLayerInfoCallback(intLegendDataPromises, legendViewModel, reactiveUtils) {
@@ -416,6 +416,10 @@ function generateQueryExpression(info, field, infoIndex, legendElement, legendEl
     return '';
   }
 }
+// checks
+function checkAllSelected(data) {
+  return data && Array.from(data.categories.entries()).every(entry => entry[1].selected);
+}
 function checkNoneSelected(data) {
   if (Array.isArray(data)) {
     return data.every(entry => !entry.selected);
@@ -800,4 +804,4 @@ function getExistingFilter(fLayerView) {
   return (fLayerView === null || fLayerView === void 0 ? void 0 : fLayerView.filter) || ((_a = fLayerView === null || fLayerView === void 0 ? void 0 : fLayerView.featureEffect) === null || _a === void 0 ? void 0 : _a.filter);
 }
 
-export { generateData as a, getParentLegendElementInfoData as b, getCategoryData as c, checkNoneSelected as d, handleFeatureCount as e, createInteractiveLegendDataForLayer as f, getTheme as g, handleFilterChange as h, handleFilter as i, getIntLegendLayerData as j, getCategoriesArray as k, checkNestedUniqueSymbol as l, calculateTotalFeatureCountForNestedSymbols as m, checkRelationshipRamp as n, calculateTotalCount as o, getNestedInfoData as p, checkNestedUniqueSymbolLegendElement as q, showAll as r, showAllNestedUniqueSymbol as s, updateStore as u, validateInteractivity as v, zoomTo as z };
+export { generateData as a, getIntLegendLayerData as b, getParentLegendElementInfoData as c, getCategoryData as d, checkNoneSelected as e, handleFeatureCount as f, getTheme as g, handleFilterChange as h, createInteractiveLegendDataForLayer as i, handleFilter as j, getNestedInfoData as k, getCategoriesArray as l, checkNestedUniqueSymbol as m, calculateTotalFeatureCountForNestedSymbols as n, checkRelationshipRamp as o, calculateTotalCount as p, checkNestedUniqueSymbolLegendElement as q, showAll as r, showAllNestedUniqueSymbol as s, updateStore as u, validateInteractivity as v, zoomTo as z };

package/dist/components/html2canvas.js

@@ -12,8 +12,11 @@ var html2canvas = createCommonjsModule(function (module, exports) {
  * Released under MIT License
  */
 (function (global, factory) {
-    module.exports = factory() ;
-}(commonjsGlobal, (function () {
+    'object' === 'object' && 'object' !== 'undefined' ? module.exports = factory() :
+    typeof undefined === 'function' && undefined.amd ? undefined(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.html2canvas = factory());
+}(commonjsGlobal, (function () { 'use strict';
+
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
 
@@ -3168,7 +3171,8 @@ var html2canvas = createCommonjsModule(function (module, exports) {
     // doesn't support 3D transforms at the moment
     var matrix3d = function (args) {
         var values = args.filter(function (arg) { return arg.type === 17 /* NUMBER_TOKEN */; }).map(function (arg) { return arg.number; });
-        var a1 = values[0], b1 = values[1]; var a2 = values[4], b2 = values[5]; var a4 = values[12], b4 = values[13];        return values.length === 16 ? [a1, b1, a2, b2, a4, b4] : null;
+        var a1 = values[0], b1 = values[1]; values[2]; values[3]; var a2 = values[4], b2 = values[5]; values[6]; values[7]; values[8]; values[9]; values[10]; values[11]; var a4 = values[12], b4 = values[13]; values[14]; values[15];
+        return values.length === 16 ? [a1, b1, a2, b2, a4, b4] : null;
     };
     var SUPPORTED_TRANSFORM_FUNCTIONS = {
         matrix: matrix,
@@ -4752,6 +4756,7 @@ var html2canvas = createCommonjsModule(function (module, exports) {
                             container.flags |= 8 /* IS_LIST_OWNER */;
                         }
                         parent.elements.push(container);
+                        childNode.slot;
                         if (childNode.shadowRoot) {
                             parseNodeTree(context, childNode.shadowRoot, container, root);
                         }

package/dist/components/icon.js

@@ -198,6 +198,6 @@ function defineCustomElement() {
             break;
     } });
 }
-defineCustomElement();
+defineCustomElement(Icon);
 
 export { Icon as I, defineCustomElement as d };