{"version":3,"sources":["../node_modules/@esri/calcite-components/dist/components/debounce.js","../node_modules/@esri/calcite-components/dist/components/floating-ui.js","../node_modules/@esri/calcite-components/dist/components/tooltip.js"],"names":["freeGlobal","global","Object","freeSelf","self","root","Function","Symbol","objectProto$1","prototype","hasOwnProperty","nativeObjectToString$1","toString","symToStringTag$1","toStringTag","undefined","nativeObjectToString","symToStringTag","baseGetTag","value","isOwn","call","tag","unmasked","e","result","getRawTag","objectToString","reWhitespace","reTrimStart","baseTrim","string","slice","index","length","test","charAt","trimmedEndIndex","replace","isObject","type","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","toNumber","isObjectLike","isSymbol","other","valueOf","isBinary","now","Date","nativeMax","Math","max","nativeMin","min","debounce","func","wait","options","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","apply","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","arguments","this","clearTimeout","cancel","flush","getSide","placement","split","getAlignment","getMainAxisFromPlacement","includes","getLengthFromAxis","axis","computeCoordsFromPlacement","_ref","rtl","coords","reference","floating","commonX","x","width","commonY","y","height","mainAxis","commonAlign","isVertical","computePosition$1","config","strategy","middleware","platform","isRTL","getElementRects","rects","statefulPlacement","middlewareData","resetCount","i","name","fn","initialPlacement","elements","nextX","nextY","data","reset","getSideObjectFromPadding","padding","top","right","bottom","left","expandPaddingObject","rectToClientRect","rect","detectOverflow","middlewareArguments","boundary","rootBoundary","elementContext","altBoundary","paddingObject","altContext","element","isElement","_await$platform$isEle","contextElement","getDocumentElement","getClippingRect","clippingClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getOffsetParent","offsetParent","elementClientRect","min$1","max$1","within","min$1$1","max$1$1","hash$1","getOppositePlacement","matched","getAlignmentSides","alignment","mainAlignmentSide","main","cross","hash","start","end","getOppositeAlignmentPlacement","sides","allPlacements","reduce","acc","side","concat","getPlacementList","autoAlignment","allowedPlacements","filter","getExpandedPlacements","oppositePlacement","flip","checkMainAxis","crossAxis","checkCrossAxis","specifiedFallbackPlacements","fallbackPlacements","fallbackStrategy","flipAlignment","detectOverflowOptions","isBasePlacement","placements","overflow","overflows","overflowsData","_middlewareData$flip","push","every","nextIndex","_middlewareData$flip$","_middlewareData$flip2","nextPlacement","resetPlacement","_overflowsData$map$so","map","d","sort","a","b","getSideOffsets","isAnySideFullyClipped","some","hide","_temp","offsets","referenceHiddenOffsets","referenceHidden","escapedOffsets","escaped","convertValueToCoords","mainAxisMulti","crossAxisMulti","rawValue","alignmentAxis","isWindow","document","location","alert","setInterval","getWindow","node","window","ownerDocument","defaultView","getComputedStyle","getNodeName","nodeName","toLowerCase","getUAString","uaData","navigator","userAgentData","brands","item","brand","version","join","userAgent","isHTMLElement","HTMLElement","Element","isShadowRoot","ShadowRoot","isOverflowElement","overflowX","overflowY","display","isTableElement","isContainingBlock","isFirefox","css","transform","perspective","willChange","contain","isLayoutViewport","isLastTraversableNode","round","getBoundingClientRect","includeScale","isFixedStrategy","_win$visualViewport$o","_win$visualViewport","_win$visualViewport$o2","_win$visualViewport2","clientRect","scaleX","scaleY","offsetWidth","offsetHeight","win","addVisualOffsets","visualViewport","offsetLeft","offsetTop","Node","documentElement","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getWindowScrollBarX","getRectRelativeToOffsetParent","isOffsetParentAnElement","isScaled","scroll","offsetRect","clientLeft","clientTop","getParentNode","assignedSlot","parentNode","host","getTrueOffsetParent","position","currentNode","parent","getContainingBlock","getDimensions","getNearestOverflowAncestor","body","getOverflowAncestors","list","_node$ownerDocument","scrollableAncestor","isBody","target","updatedList","getClientRectFromClippingAncestor","clippingParent","html","clientWidth","clientHeight","layoutViewport","getViewportRect","getInnerBoundingClientRect","_element$ownerDocumen","scrollWidth","scrollHeight","direction","getDocumentRect","getClippingAncestors","clippingAncestors","nearestEscapableParent","getNearestParentCapableOfEscapingClipping","clipperElement","child","rootNode","getRootNode","contains","next","mainClippingAncestors","firstClippingAncestor","clippingRect","accRect","clippingAncestor","getClientRects","Array","from","autoUpdate","update","ancestorScroll","_ancestorScroll","ancestorResize","elementResize","animationFrame","ancestors","forEach","ancestor","addEventListener","passive","frameId","observer","initialUpdate","ResizeObserver","observe","prevRefRect","frameLoop","nextRefRect","requestAnimationFrame","_observer","removeEventListener","disconnect","cancelAnimationFrame","computePosition","configOverrides","globalThis","floatingUINonChromiumPositioningFix","floatingUIBrowserCheck","patchFloatingUiForNonChromiumBrowsers","Build","isBrowser","placementDataAttribute","effectivePlacements","FloatingCSS","animation","animationActive","getMiddleware","disableFlip","flipPlacements","offsetDistance","offsetSkidding","arrowEl","defaultMiddleware","limiter","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","diffCoords","currentIndex","_middlewareData$autoP","_middlewareData$autoP2","autoPlacement","currentPlacement","currentOverflows","allOverflows","_middlewareData$autoP3","_middlewareData$autoP4","placementsSortedByLeastOverflow","placementThatFitsOnAllSides","_placementsSortedByLe","find","arrowDimensions","minProp","maxProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","center","offset","alignmentPadding","shouldAddOffset","alignmentOffset","arrow","filterComputedPlacements","el","filteredPlacements","console","warn","tagName","trim","getEffectivePlacement","floatingEl","getElementDir","reverse","reposition","component","delayed","open","debouncedReposition","positionFloatingUI","referenceEl","overlayPositioning","includeArrow","effectivePlacement","arrowX","arrowY","assign","style","_a","pointerEvents","visibility","setAttribute","cleanupMap","WeakMap","connectFloatingUI","disconnectFloatingUI","moveOffScreen","runAutoUpdate","_refEl","_floatingEl","updateCallback","set","getTransitionTarget","handleTransitionElTransitionEnd","cleanup","get","delete","defaultOffsetDistance","ceil","hypot","updateAfterClose","shadowRoot","event","floatingTransitionEl","propertyName","classList","closestElementCrossShadowBoundary","getFloatingElFromTransitionTarget","CSS","ARIA_DESCRIBED_BY","manager","registeredElements","hoverTimeouts","registeredElementCount","queryTooltip","composedPath","registeredElement","pathEl","has","keyDownHandler","key","activeTooltipEl","clearHoverTimeout","toggleTooltip","mouseEnterShow","hoverEvent","mouseLeaveHide","clickHandler","isPrimaryPointerButton","clickedTooltip","closeOnClick","focusShow","focusEvent","blurHide","hoverToggle","tooltip","closeExistingTooltip","addListeners","removeListeners","capture","timeoutId","hoverTooltip","activeTooltipHover","focusTooltip","Tooltip","proxyCustomElement","__registerHost","__attachShadow","guid","hasLoaded","setUpReferenceElement","removeReferences","effectiveReferenceElement","getReferenceElement","referenceElement","addReferences","getId","id","registerElement","removeAttribute","unregisterElement","queryElementRoots","label","displayed","hidden","h","Host","toAriaBoolean","role","class","ref","defineCustomElement","customElements","define"],"mappings":"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","file":"static/js/40.52e997a1.chunk.js","sourcesContent":["/*!\n * All material copyright ESRI, All Rights Reserved, unless otherwise specified.\n * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.\n * v1.0.0-beta.97\n */\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\n/** Used for built-in method references. */\nvar objectProto$1 = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto$1.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString$1 = objectProto$1.toString;\n\n/** Built-in value references. */\nvar symToStringTag$1 = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag$1),\n      tag = value[symToStringTag$1];\n\n  try {\n    value[symToStringTag$1] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString$1.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag$1] = tag;\n    } else {\n      delete value[symToStringTag$1];\n    }\n  }\n  return result;\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\n/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nexport { Symbol as S, isSymbol as a, baseGetTag as b, isObjectLike as c, debounce as d, freeGlobal as f, isObject as i, root as r };\n","/*!\n * All material copyright ESRI, All Rights Reserved, unless otherwise specified.\n * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.\n * v1.0.0-beta.97\n */\nimport { c as getElementDir, o as closestElementCrossShadowBoundary } from './dom.js';\nimport { Build } from '@stencil/core/internal/client/index.js';\nimport { d as debounce } from './debounce.js';\n\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\n\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\n\nfunction getMainAxisFromPlacement(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'x' : 'y';\n}\n\nfunction getLengthFromAxis(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const mainAxis = getMainAxisFromPlacement(placement);\n  const length = getLengthFromAxis(mainAxis);\n  const commonAlign = reference[length] / 2 - floating[length] / 2;\n  const side = getSide(placement);\n  const isVertical = mainAxis === 'x';\n  let coords;\n\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[mainAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n\n    case 'end':\n      coords[mainAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a reference element when it is given a certain positioning strategy.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\n\nconst computePosition$1 = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n\n  for (let i = 0; i < middleware.length; i++) {\n    const {\n      name,\n      fn\n    } = middleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = { ...middlewareData,\n      [name]: { ...middlewareData[name],\n        ...data\n      }\n    };\n\n    if (reset && resetCount <= 50) {\n      resetCount++;\n\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n\n      i = -1;\n      continue;\n    }\n  }\n\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\n\nfunction getSideObjectFromPadding(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\n\nfunction rectToClientRect(rect) {\n  return { ...rect,\n    top: rect.y,\n    left: rect.x,\n    right: rect.x + rect.width,\n    bottom: rect.y + rect.height\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(middlewareArguments, options) {\n  var _await$platform$isEle;\n\n  if (options === void 0) {\n    options = {};\n  }\n\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = middlewareArguments;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = options;\n  const paddingObject = getSideObjectFromPadding(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    rect: elementContext === 'floating' ? { ...rects.floating,\n      x,\n      y\n    } : rects.reference,\n    offsetParent: await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating)),\n    strategy\n  }) : rects[elementContext]);\n  return {\n    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,\n    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,\n    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,\n    right: elementClientRect.right - clippingClientRect.right + paddingObject.right\n  };\n}\n\nconst min$1 = Math.min;\nconst max$1 = Math.max;\n\nfunction within(min$1$1, value, max$1$1) {\n  return max$1(min$1$1, min$1(value, max$1$1));\n}\n\n/**\n * Positions an inner element of the floating element such that it is centered\n * to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n\n  async fn(middlewareArguments) {\n    // Since `element` is required, we don't Partial<> the type\n    const {\n      element,\n      padding = 0\n    } = options != null ? options : {};\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform\n    } = middlewareArguments;\n\n    if (element == null) {\n\n      return {};\n    }\n\n    const paddingObject = getSideObjectFromPadding(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getMainAxisFromPlacement(placement);\n    const alignment = getAlignment(placement);\n    const length = getLengthFromAxis(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const minProp = axis === 'y' ? 'top' : 'left';\n    const maxProp = axis === 'y' ? 'bottom' : 'right';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;\n\n    if (clientSize === 0) {\n      clientSize = rects.floating[length];\n    }\n\n    const centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds\n\n    const min = paddingObject[minProp];\n    const max = clientSize - arrowDimensions[length] - paddingObject[maxProp];\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = within(min, center, max); // Make sure that arrow points at the reference\n\n    const alignmentPadding = alignment === 'start' ? paddingObject[minProp] : paddingObject[maxProp];\n    const shouldAddOffset = alignmentPadding > 0 && center !== offset && rects.reference[length] <= rects.floating[length];\n    const alignmentOffset = shouldAddOffset ? center < min ? min - center : max - center : 0;\n    return {\n      [axis]: coords[axis] - alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset\n      }\n    };\n  }\n\n});\n\nconst hash$1 = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, matched => hash$1[matched]);\n}\n\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n\n  const alignment = getAlignment(placement);\n  const mainAxis = getMainAxisFromPlacement(placement);\n  const length = getLengthFromAxis(mainAxis);\n  let mainAlignmentSide = mainAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n\n  return {\n    main: mainAlignmentSide,\n    cross: getOppositePlacement(mainAlignmentSide)\n  };\n}\n\nconst hash = {\n  start: 'end',\n  end: 'start'\n};\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, matched => hash[matched]);\n}\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst allPlacements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-start\", side + \"-end\"), []);\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n\n    return true;\n  });\n}\n\n/**\n * Automatically chooses the `placement` which has the most space available.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  return {\n    name: 'autoPlacement',\n    options,\n\n    async fn(middlewareArguments) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _middlewareData$autoP3, _middlewareData$autoP4, _placementsSortedByLe;\n\n      const {\n        x,\n        y,\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = middlewareArguments;\n      const {\n        alignment = null,\n        allowedPlacements = allPlacements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = options;\n      const placements = getPlacementList(alignment, autoAlignment, allowedPlacements);\n      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);\n      const currentIndex = (_middlewareData$autoP = (_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.index) != null ? _middlewareData$autoP : 0;\n      const currentPlacement = placements[currentIndex];\n\n      if (currentPlacement == null) {\n        return {};\n      }\n\n      const {\n        main,\n        cross\n      } = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))); // Make `computeCoords` start from the right place\n\n      if (placement !== currentPlacement) {\n        return {\n          x,\n          y,\n          reset: {\n            placement: placements[0]\n          }\n        };\n      }\n\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[main], overflow[cross]];\n      const allOverflows = [...((_middlewareData$autoP3 = (_middlewareData$autoP4 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP4.overflows) != null ? _middlewareData$autoP3 : []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements[currentIndex + 1]; // There are more placements to check\n\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n\n      const placementsSortedByLeastOverflow = allOverflows.slice().sort((a, b) => a.overflows[0] - b.overflows[0]);\n      const placementThatFitsOnAllSides = (_placementsSortedByLe = placementsSortedByLeastOverflow.find(_ref => {\n        let {\n          overflows\n        } = _ref;\n        return overflows.every(overflow => overflow <= 0);\n      })) == null ? void 0 : _placementsSortedByLe.placement;\n      const resetPlacement = placementThatFitsOnAllSides != null ? placementThatFitsOnAllSides : placementsSortedByLeastOverflow[0].placement;\n\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n\n      return {};\n    }\n\n  };\n};\n\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\n\n/**\n * Changes the placement of the floating element to one that will fit if the\n * initially specified `placement` does not.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  return {\n    name: 'flip',\n    options,\n\n    async fn(middlewareArguments) {\n      var _middlewareData$flip;\n\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = middlewareArguments;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = options;\n      const side = getSide(placement);\n      const isBasePlacement = side === initialPlacement;\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n\n      if (checkCrossAxis) {\n        const {\n          main,\n          cross\n        } = getAlignmentSides(placement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n        overflows.push(overflow[main], overflow[cross]);\n      }\n\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }]; // One or more sides is overflowing\n\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip$, _middlewareData$flip2;\n\n        const nextIndex = ((_middlewareData$flip$ = (_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) != null ? _middlewareData$flip$ : 0) + 1;\n        const nextPlacement = placements[nextIndex];\n\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        let resetPlacement = 'bottom';\n\n        switch (fallbackStrategy) {\n          case 'bestFit':\n            {\n              var _overflowsData$map$so;\n\n              const placement = (_overflowsData$map$so = overflowsData.map(d => [d, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0].placement;\n\n              if (placement) {\n                resetPlacement = placement;\n              }\n\n              break;\n            }\n\n          case 'initialPlacement':\n            resetPlacement = initialPlacement;\n            break;\n        }\n\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n\n      return {};\n    }\n\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\n\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (_temp) {\n  let {\n    strategy = 'referenceHidden',\n    ...detectOverflowOptions\n  } = _temp === void 0 ? {} : _temp;\n  return {\n    name: 'hide',\n\n    async fn(middlewareArguments) {\n      const {\n        rects\n      } = middlewareArguments;\n\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(middlewareArguments, { ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(middlewareArguments, { ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n\n        default:\n          {\n            return {};\n          }\n      }\n    }\n\n  };\n};\n\nasync function convertValueToCoords(middlewareArguments, value) {\n  const {\n    placement,\n    platform,\n    elements\n  } = middlewareArguments;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getMainAxisFromPlacement(placement) === 'x';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = typeof value === 'function' ? value(middlewareArguments) : value; // eslint-disable-next-line prefer-const\n\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\n  };\n\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n/**\n * Displaces the floating element from its reference element.\n * @see https://floating-ui.com/docs/offset\n */\n\nconst offset = function (value) {\n  if (value === void 0) {\n    value = 0;\n  }\n\n  return {\n    name: 'offset',\n    options: value,\n\n    async fn(middlewareArguments) {\n      const {\n        x,\n        y\n      } = middlewareArguments;\n      const diffCoords = await convertValueToCoords(middlewareArguments, value);\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: diffCoords\n      };\n    }\n\n  };\n};\n\nfunction getCrossAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\n\n/**\n * Shifts the floating element in order to keep it in view when it will overflow\n * a clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  return {\n    name: 'shift',\n    options,\n\n    async fn(middlewareArguments) {\n      const {\n        x,\n        y,\n        placement\n      } = middlewareArguments;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = options;\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);\n      const mainAxis = getMainAxisFromPlacement(getSide(placement));\n      const crossAxis = getCrossAxis(mainAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = within(min, mainAxisCoord, max);\n      }\n\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = within(min, crossAxisCoord, max);\n      }\n\n      const limitedCoords = limiter.fn({ ...middlewareArguments,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return { ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y\n        }\n      };\n    }\n\n  };\n};\n\nfunction isWindow(value) {\n  return value && value.document && value.location && value.alert && value.setInterval;\n}\nfunction getWindow(node) {\n  if (node == null) {\n    return window;\n  }\n\n  if (!isWindow(node)) {\n    const ownerDocument = node.ownerDocument;\n    return ownerDocument ? ownerDocument.defaultView || window : window;\n  }\n\n  return node;\n}\n\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\n\nfunction getNodeName(node) {\n  return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : '';\n}\n\nfunction getUAString() {\n  const uaData = navigator.userAgentData;\n\n  if (uaData != null && uaData.brands) {\n    return uaData.brands.map(item => item.brand + \"/\" + item.version).join(' ');\n  }\n\n  return navigator.userAgent;\n}\n\nfunction isHTMLElement(value) {\n  return value instanceof getWindow(value).HTMLElement;\n}\nfunction isElement(value) {\n  return value instanceof getWindow(value).Element;\n}\nfunction isNode(value) {\n  return value instanceof getWindow(value).Node;\n}\nfunction isShadowRoot(node) {\n  // Browsers without `ShadowRoot` support\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n\n  const OwnElement = getWindow(node).ShadowRoot;\n  return node instanceof OwnElement || node instanceof ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  // Firefox wants us to check `-x` and `-y` variations as well\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isContainingBlock(element) {\n  // TODO: Try and use feature detection here instead\n  const isFirefox = /firefox/i.test(getUAString());\n  const css = getComputedStyle(element); // This is non-exhaustive but covers the most common CSS properties that\n  // create a containing block.\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n\n  return css.transform !== 'none' || css.perspective !== 'none' || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective'].some(value => css.willChange.includes(value)) || ['paint', 'layout', 'strict', 'content'].some( // TS 4.1 compat\n  value => {\n    const contain = css.contain;\n    return contain != null ? contain.includes(value) : false;\n  });\n}\nfunction isLayoutViewport() {\n  // Not Safari\n  return !/^((?!chrome|android).)*safari/i.test(getUAString()); // Feature detection for this fails in various ways\n  // • Always-visible scrollbar or not\n  // • Width of <html>, etc.\n  // const vV = win.visualViewport;\n  // return vV ? Math.abs(win.innerWidth / vV.scale - vV.width) < 0.5 : true;\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\n\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy) {\n  var _win$visualViewport$o, _win$visualViewport, _win$visualViewport$o2, _win$visualViewport2;\n\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n\n  const clientRect = element.getBoundingClientRect();\n  let scaleX = 1;\n  let scaleY = 1;\n\n  if (includeScale && isHTMLElement(element)) {\n    scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;\n    scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;\n  }\n\n  const win = isElement(element) ? getWindow(element) : window;\n  const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;\n  const x = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scaleX;\n  const y = (clientRect.top + (addVisualOffsets ? (_win$visualViewport$o2 = (_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) != null ? _win$visualViewport$o2 : 0 : 0)) / scaleY;\n  const width = clientRect.width / scaleX;\n  const height = clientRect.height / scaleY;\n  return {\n    width,\n    height,\n    top: y,\n    right: x + width,\n    bottom: y + height,\n    left: x,\n    x,\n    y\n  };\n}\n\nfunction getDocumentElement(node) {\n  return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;\n}\n\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n\n  return {\n    scrollLeft: element.pageXOffset,\n    scrollTop: element.pageYOffset\n  };\n}\n\nfunction getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;\n}\n\nfunction isScaled(element) {\n  const rect = getBoundingClientRect(element);\n  return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight;\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const rect = getBoundingClientRect(element, // @ts-ignore - checked above (TS 4.1 compat)\n  isOffsetParentAnElement && isScaled(offsetParent), strategy === 'fixed');\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = {\n    x: 0,\n    y: 0\n  };\n\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent, true);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n\n  return {\n    x: rect.left + scroll.scrollLeft - offsets.x,\n    y: rect.top + scroll.scrollTop - offsets.y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n\n  return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle\n    // @ts-ignore\n    node.assignedSlot || // step into the shadow DOM of the parent of a slotted node\n    node.parentNode || ( // DOM Element detected\n    isShadowRoot(node) ? node.host : null) || // ShadowRoot detected\n    getDocumentElement(node) // fallback\n\n  );\n}\n\nfunction getTrueOffsetParent(element) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n\n  return element.offsetParent;\n}\n\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n\n  if (isShadowRoot(currentNode)) {\n    currentNode = currentNode.host;\n  }\n\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else {\n      const parent = currentNode.parentNode;\n      currentNode = isShadowRoot(parent) ? parent.host : parent;\n    }\n  }\n\n  return null;\n} // Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\n\n\nfunction getOffsetParent(element) {\n  const window = getWindow(element);\n  let offsetParent = getTrueOffsetParent(element);\n\n  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {\n    offsetParent = getTrueOffsetParent(offsetParent);\n  }\n\n  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {\n    return window;\n  }\n\n  return offsetParent || getContainingBlock(element) || window;\n}\n\nfunction getDimensions(element) {\n  if (isHTMLElement(element)) {\n    return {\n      width: element.offsetWidth,\n      height: element.offsetHeight\n    };\n  }\n\n  const rect = getBoundingClientRect(element);\n  return {\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n\n  if (offsetParent === documentElement) {\n    return rect;\n  }\n\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = {\n    x: 0,\n    y: 0\n  };\n\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent, true);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } // This doesn't appear to be need to be negated.\n    // else if (documentElement) {\n    //   offsets.x = getWindowScrollBarX(documentElement);\n    // }\n\n  }\n\n  return { ...rect,\n    x: rect.x - scroll.scrollLeft + offsets.x,\n    y: rect.y - scroll.scrollTop + offsets.y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const layoutViewport = isLayoutViewport();\n\n    if (layoutViewport || !layoutViewport && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable\n\nfunction getDocumentRect(element) {\n  var _element$ownerDocumen;\n\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;\n  const width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);\n  const height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n\n  if (getComputedStyle(body || html).direction === 'rtl') {\n    x += max(html.clientWidth, body ? body.clientWidth : 0) - width;\n  }\n\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n\n  if (isLastTraversableNode(parentNode)) {\n    // @ts-ignore assume body is always available\n    return node.ownerDocument.body;\n  }\n\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n\n  return getNearestOverflowAncestor(parentNode);\n}\n\nfunction getOverflowAncestors(node, list) {\n  var _node$ownerDocument;\n\n  if (list === void 0) {\n    list = [];\n  }\n\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);\n  const win = getWindow(scrollableAncestor);\n  const target = isBody ? [win].concat(win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []) : scrollableAncestor;\n  const updatedList = list.concat(target);\n  return isBody ? updatedList : // @ts-ignore: isBody tells us target will be an HTMLElement here\n  updatedList.concat(getOverflowAncestors(target));\n}\n\nfunction contains(parent, child) {\n  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode(); // First, attempt with faster native method\n\n  if (parent.contains(child)) {\n    return true;\n  } // then fallback to custom implementation with Shadow DOM support\n  else if (rootNode && isShadowRoot(rootNode)) {\n    let next = child;\n\n    do {\n      // use `===` replace node.isSameNode()\n      if (next && parent === next) {\n        return true;\n      } // @ts-ignore: need a better way to handle this...\n\n\n      next = next.parentNode || next.host;\n    } while (next);\n  }\n\n  return false;\n}\n\nfunction getNearestParentCapableOfEscapingClipping(element, clippingAncestors) {\n  let currentNode = element;\n\n  while (currentNode && !isLastTraversableNode(currentNode) && // @ts-expect-error\n  !clippingAncestors.includes(currentNode)) {\n    if (isElement(currentNode) && ['absolute', 'fixed'].includes(getComputedStyle(currentNode).position)) {\n      break;\n    }\n\n    const parentNode = getParentNode(currentNode);\n    currentNode = isShadowRoot(parentNode) ? parentNode.host : parentNode;\n  }\n\n  return currentNode;\n}\n\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, false, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  return {\n    top,\n    left,\n    x: left,\n    y: top,\n    right: left + element.clientWidth,\n    bottom: top + element.clientHeight,\n    width: element.clientWidth,\n    height: element.clientHeight\n  };\n}\n\nfunction getClientRectFromClippingAncestor(element, clippingParent, strategy) {\n  if (clippingParent === 'viewport') {\n    return rectToClientRect(getViewportRect(element, strategy));\n  }\n\n  if (isElement(clippingParent)) {\n    return getInnerBoundingClientRect(clippingParent, strategy);\n  }\n\n  return rectToClientRect(getDocumentRect(getDocumentElement(element)));\n} // A \"clipping ancestor\" is an overflowable container with the characteristic of\n// clipping (or hiding) overflowing elements with a position different from\n// `initial`\n\n\nfunction getClippingAncestors(element) {\n  const clippingAncestors = getOverflowAncestors(element);\n  const nearestEscapableParent = getNearestParentCapableOfEscapingClipping(element, clippingAncestors);\n  let clipperElement = null;\n\n  if (nearestEscapableParent && isHTMLElement(nearestEscapableParent)) {\n    const offsetParent = getOffsetParent(nearestEscapableParent);\n\n    if (isOverflowElement(nearestEscapableParent)) {\n      clipperElement = nearestEscapableParent;\n    } else if (isHTMLElement(offsetParent)) {\n      clipperElement = offsetParent;\n    }\n  }\n\n  if (!isElement(clipperElement)) {\n    return [];\n  } // @ts-ignore isElement check ensures we return Array<Element>\n\n\n  return clippingAncestors.filter(clippingAncestors => clipperElement && isElement(clippingAncestors) && contains(clippingAncestors, clipperElement) && getNodeName(clippingAncestors) !== 'body');\n} // Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors\n\n\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const mainClippingAncestors = boundary === 'clippingAncestors' ? getClippingAncestors(element) : [].concat(boundary);\n  const clippingAncestors = [...mainClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nconst platform = {\n  getClippingRect,\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  isElement,\n  getDimensions,\n  getOffsetParent,\n  getDocumentElement,\n  getElementRects: _ref => {\n    let {\n      reference,\n      floating,\n      strategy\n    } = _ref;\n    return {\n      reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),\n      floating: { ...getDimensions(floating),\n        x: 0,\n        y: 0\n      }\n    };\n  },\n  getClientRects: element => Array.from(element.getClientRects()),\n  isRTL: element => getComputedStyle(element).direction === 'rtl'\n};\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  const {\n    ancestorScroll: _ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = true,\n    animationFrame = false\n  } = options;\n  const ancestorScroll = _ancestorScroll && !animationFrame;\n  const ancestors = ancestorScroll || ancestorResize ? [...(isElement(reference) ? getOverflowAncestors(reference) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  let observer = null;\n\n  if (elementResize) {\n    let initialUpdate = true;\n    observer = new ResizeObserver(() => {\n      if (!initialUpdate) {\n        update();\n      }\n\n      initialUpdate = false;\n    });\n    isElement(reference) && !animationFrame && observer.observe(reference);\n    observer.observe(floating);\n  }\n\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n\n  if (animationFrame) {\n    frameLoop();\n  }\n\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n\n  update();\n  return () => {\n    var _observer;\n\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    (_observer = observer) == null ? void 0 : _observer.disconnect();\n    observer = null;\n\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a reference element when it is given a certain CSS positioning\n * strategy.\n */\n\nconst computePosition = (reference, floating, options) => computePosition$1(reference, floating, {\n  platform,\n  ...options\n});\n\n/**\n * This module helps users provide custom configuration for component internals.\n *\n * @internal\n */\nconst configOverrides = globalThis[\"calciteComponentsConfig\"];\nconst config = {\n  /**\n   * We apply a custom fix to improve positioning for non-Chromium browsers.\n   * The fix comes at a performance cost, so provides users a way to opt-out if necessary.\n   *\n   * @internal\n   */\n  floatingUINonChromiumPositioningFix: true,\n  ...configOverrides\n};\n\nconst floatingUIBrowserCheck = patchFloatingUiForNonChromiumBrowsers();\nasync function patchFloatingUiForNonChromiumBrowsers() {\n  function getUAString() {\n    const uaData = navigator.userAgentData;\n    if (uaData === null || uaData === void 0 ? void 0 : uaData.brands) {\n      return uaData.brands.map((item) => `${item.brand}/${item.version}`).join(\" \");\n    }\n    return navigator.userAgent;\n  }\n  if (Build.isBrowser &&\n    config.floatingUINonChromiumPositioningFix &&\n    // ⚠️ browser-sniffing is not a best practice and should be avoided ⚠️\n    /firefox|safari/i.test(getUAString())) {\n    const { getClippingRect, getElementRects, getOffsetParent } = await import('./nonChromiumPlatformUtils.js');\n    platform.getClippingRect = getClippingRect;\n    platform.getOffsetParent = getOffsetParent;\n    platform.getElementRects = getElementRects;\n  }\n}\nconst placementDataAttribute = \"data-placement\";\n/**\n * Exported for testing purposes only\n */\nconst repositionDebounceTimeout = 100;\nconst effectivePlacements = [\n  \"top\",\n  \"bottom\",\n  \"right\",\n  \"left\",\n  \"top-start\",\n  \"top-end\",\n  \"bottom-start\",\n  \"bottom-end\",\n  \"right-start\",\n  \"right-end\",\n  \"left-start\",\n  \"left-end\"\n];\nconst defaultMenuPlacement = \"bottom-start\";\nconst FloatingCSS = {\n  animation: \"calcite-floating-ui-anim\",\n  animationActive: \"calcite-floating-ui-anim--active\"\n};\nfunction getMiddleware({ placement, disableFlip, flipPlacements, offsetDistance, offsetSkidding, arrowEl, type }) {\n  const defaultMiddleware = [shift(), hide()];\n  if (type === \"menu\") {\n    return [\n      ...defaultMiddleware,\n      flip({\n        fallbackPlacements: flipPlacements || [\"top-start\", \"top\", \"top-end\", \"bottom-start\", \"bottom\", \"bottom-end\"]\n      })\n    ];\n  }\n  if (type === \"popover\" || type === \"tooltip\") {\n    const middleware = [\n      ...defaultMiddleware,\n      offset({\n        mainAxis: typeof offsetDistance === \"number\" ? offsetDistance : 0,\n        crossAxis: typeof offsetSkidding === \"number\" ? offsetSkidding : 0\n      })\n    ];\n    if (placement === \"auto\" || placement === \"auto-start\" || placement === \"auto-end\") {\n      middleware.push(autoPlacement({ alignment: placement === \"auto-start\" ? \"start\" : placement === \"auto-end\" ? \"end\" : null }));\n    }\n    else if (!disableFlip) {\n      middleware.push(flip(flipPlacements ? { fallbackPlacements: flipPlacements } : {}));\n    }\n    if (arrowEl) {\n      middleware.push(arrow({\n        element: arrowEl\n      }));\n    }\n    return middleware;\n  }\n  return [];\n}\nfunction filterComputedPlacements(placements, el) {\n  const filteredPlacements = placements.filter((placement) => effectivePlacements.includes(placement));\n  if (filteredPlacements.length !== placements.length) {\n    console.warn(`${el.tagName}: Invalid value found in: flipPlacements. Try any of these: ${effectivePlacements\n      .map((placement) => `\"${placement}\"`)\n      .join(\", \")\n      .trim()}`, { el });\n  }\n  return filteredPlacements;\n}\n/*\nIn floating-ui, \"*-start\" and \"*-end\" are already flipped in RTL.\nThere is no need for our \"*-leading\" and \"*-trailing\" values anymore.\nhttps://github.com/floating-ui/floating-ui/issues/1530\nhttps://github.com/floating-ui/floating-ui/issues/1563\n*/\nfunction getEffectivePlacement(floatingEl, placement) {\n  const placements = [\"left\", \"right\"];\n  if (getElementDir(floatingEl) === \"rtl\") {\n    placements.reverse();\n  }\n  return placement\n    .replace(/-leading/gi, \"-start\")\n    .replace(/-trailing/gi, \"-end\")\n    .replace(/leading/gi, placements[0])\n    .replace(/trailing/gi, placements[1]);\n}\n/**\n * Convenience function to manage `reposition` calls for FloatingUIComponents that use `positionFloatingUI.\n *\n * Note: this is not needed for components that use `calcite-popover`.\n *\n * @param component\n * @param options\n * @param options.referenceEl\n * @param options.floatingEl\n * @param options.overlayPositioning\n * @param options.placement\n * @param options.disableFlip\n * @param options.flipPlacements\n * @param options.offsetDistance\n * @param options.offsetSkidding\n * @param options.arrowEl\n * @param options.type\n * @param delayed\n */\nasync function reposition(component, options, delayed = false) {\n  if (!component.open) {\n    return;\n  }\n  return delayed ? debouncedReposition(options) : positionFloatingUI(options);\n}\nconst debouncedReposition = debounce(positionFloatingUI, repositionDebounceTimeout, {\n  leading: true,\n  maxWait: repositionDebounceTimeout\n});\n/**\n * Positions the floating element relative to the reference element.\n *\n * **Note:** exported for testing purposes only\n *\n * @param root0\n * @param root0.referenceEl\n * @param root0.floatingEl\n * @param root0.overlayPositioning\n * @param root0.placement\n * @param root0.disableFlip\n * @param root0.flipPlacements\n * @param root0.offsetDistance\n * @param root0.offsetSkidding\n * @param root0.arrowEl\n * @param root0.type\n * @param root0.includeArrow\n */\nasync function positionFloatingUI({ referenceEl, floatingEl, overlayPositioning = \"absolute\", placement, disableFlip, flipPlacements, offsetDistance, offsetSkidding, includeArrow = false, arrowEl, type }) {\n  var _a;\n  if (!referenceEl || !floatingEl || (includeArrow && !arrowEl)) {\n    return null;\n  }\n  await floatingUIBrowserCheck;\n  const { x, y, placement: effectivePlacement, strategy: position, middlewareData } = await computePosition(referenceEl, floatingEl, {\n    strategy: overlayPositioning,\n    placement: placement === \"auto\" || placement === \"auto-start\" || placement === \"auto-end\"\n      ? undefined\n      : getEffectivePlacement(floatingEl, placement),\n    middleware: getMiddleware({\n      placement,\n      disableFlip,\n      flipPlacements,\n      offsetDistance,\n      offsetSkidding,\n      arrowEl,\n      type\n    })\n  });\n  if (middlewareData === null || middlewareData === void 0 ? void 0 : middlewareData.arrow) {\n    const { x: arrowX, y: arrowY } = middlewareData.arrow;\n    Object.assign(arrowEl.style, {\n      left: arrowX != null ? `${arrowX}px` : \"\",\n      top: arrowY != null ? `${arrowY}px` : \"\"\n    });\n  }\n  const referenceHidden = (_a = middlewareData === null || middlewareData === void 0 ? void 0 : middlewareData.hide) === null || _a === void 0 ? void 0 : _a.referenceHidden;\n  const visibility = referenceHidden ? \"hidden\" : null;\n  const pointerEvents = visibility ? \"none\" : null;\n  floatingEl.setAttribute(placementDataAttribute, effectivePlacement);\n  const transform = `translate(${Math.round(x)}px,${Math.round(y)}px)`;\n  Object.assign(floatingEl.style, {\n    visibility,\n    pointerEvents,\n    position,\n    top: \"0\",\n    left: \"0\",\n    transform\n  });\n}\n/**\n * Exported for testing purposes only\n *\n * @internal\n */\nconst cleanupMap = new WeakMap();\n/**\n * Helper to set up floating element interactions on connectedCallback.\n *\n * @param component\n * @param referenceEl\n * @param floatingEl\n */\nfunction connectFloatingUI(component, referenceEl, floatingEl) {\n  if (!floatingEl || !referenceEl) {\n    return;\n  }\n  disconnectFloatingUI(component, referenceEl, floatingEl);\n  const position = component.overlayPositioning;\n  // ensure position matches for initial positioning\n  floatingEl.style.position = position;\n  if (position === \"absolute\") {\n    moveOffScreen(floatingEl);\n  }\n  const runAutoUpdate = Build.isBrowser\n    ? autoUpdate\n    : (_refEl, _floatingEl, updateCallback) => {\n      updateCallback();\n      return () => {\n        /* noop */\n      };\n    };\n  cleanupMap.set(component, runAutoUpdate(referenceEl, floatingEl, () => component.reposition()));\n}\n/**\n * Helper to tear down floating element interactions on disconnectedCallback.\n *\n * @param component\n * @param referenceEl\n * @param floatingEl\n */\nfunction disconnectFloatingUI(component, referenceEl, floatingEl) {\n  if (!floatingEl || !referenceEl) {\n    return;\n  }\n  getTransitionTarget(floatingEl).removeEventListener(\"transitionend\", handleTransitionElTransitionEnd);\n  const cleanup = cleanupMap.get(component);\n  if (cleanup) {\n    cleanup();\n  }\n  cleanupMap.delete(component);\n}\nconst visiblePointerSize = 4;\n/**\n * Default offset the position of the floating element away from the reference element.\n *\n * @default 6\n */\nconst defaultOffsetDistance = Math.ceil(Math.hypot(visiblePointerSize, visiblePointerSize));\n/**\n * This utils applies floating element styles to avoid affecting layout when closed.\n *\n * This should be called when the closing transition will start.\n *\n * @param floatingEl\n */\nfunction updateAfterClose(floatingEl) {\n  if (!floatingEl || floatingEl.style.position !== \"absolute\") {\n    return;\n  }\n  getTransitionTarget(floatingEl).addEventListener(\"transitionend\", handleTransitionElTransitionEnd);\n}\nfunction getTransitionTarget(floatingEl) {\n  // assumes floatingEl w/ shadowRoot is a FloatingUIComponent\n  return floatingEl.shadowRoot || floatingEl;\n}\nfunction handleTransitionElTransitionEnd(event) {\n  const floatingTransitionEl = event.target;\n  if (\n  // using any prop from floating-ui transition\n  event.propertyName === \"opacity\" &&\n    floatingTransitionEl.classList.contains(FloatingCSS.animation)) {\n    const floatingEl = getFloatingElFromTransitionTarget(floatingTransitionEl);\n    moveOffScreen(floatingEl);\n    getTransitionTarget(floatingEl).removeEventListener(\"transitionend\", handleTransitionElTransitionEnd);\n  }\n}\nfunction moveOffScreen(floatingEl) {\n  floatingEl.style.transform = \"\";\n  floatingEl.style.top = \"-99999px\";\n  floatingEl.style.left = \"-99999px\";\n}\nfunction getFloatingElFromTransitionTarget(floatingTransitionEl) {\n  return closestElementCrossShadowBoundary(floatingTransitionEl, `[${placementDataAttribute}]`);\n}\n\nexport { FloatingCSS as F, disconnectFloatingUI as a, defaultOffsetDistance as b, connectFloatingUI as c, defaultMenuPlacement as d, rectToClientRect as e, filterComputedPlacements as f, reposition as r, updateAfterClose as u };\n","/*!\n * All material copyright ESRI, All Rights Reserved, unless otherwise specified.\n * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.\n * v1.0.0-beta.97\n */\nimport { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client/index.js';\nimport { g as guid } from './guid.js';\nimport { b as defaultOffsetDistance, c as connectFloatingUI, u as updateAfterClose, a as disconnectFloatingUI, r as reposition, F as FloatingCSS } from './floating-ui.js';\nimport { i as isPrimaryPointerButton, q as queryElementRoots, t as toAriaBoolean } from './dom.js';\n\nconst CSS = {\n  container: \"container\",\n  arrow: \"arrow\"\n};\nconst TOOLTIP_DELAY_MS = 500;\nconst ARIA_DESCRIBED_BY = \"aria-describedby\";\n\nclass TooltipManager {\n  constructor() {\n    // --------------------------------------------------------------------------\n    //\n    //  Private Properties\n    //\n    // --------------------------------------------------------------------------\n    this.registeredElements = new WeakMap();\n    this.hoverTimeouts = new WeakMap();\n    this.registeredElementCount = 0;\n    // --------------------------------------------------------------------------\n    //\n    //  Private Methods\n    //\n    // --------------------------------------------------------------------------\n    this.queryTooltip = (composedPath) => {\n      const { registeredElements } = this;\n      const registeredElement = composedPath.find((pathEl) => registeredElements.has(pathEl));\n      return registeredElements.get(registeredElement);\n    };\n    this.keyDownHandler = (event) => {\n      if (event.key === \"Escape\") {\n        const { activeTooltipEl } = this;\n        if (activeTooltipEl) {\n          this.clearHoverTimeout(activeTooltipEl);\n          this.toggleTooltip(activeTooltipEl, false);\n        }\n      }\n    };\n    this.mouseEnterShow = (event) => {\n      this.hoverEvent(event, true);\n    };\n    this.mouseLeaveHide = (event) => {\n      this.hoverEvent(event, false);\n    };\n    this.clickHandler = (event) => {\n      if (!isPrimaryPointerButton(event)) {\n        return;\n      }\n      const clickedTooltip = this.queryTooltip(event.composedPath());\n      this.clickedTooltip = clickedTooltip;\n      if (clickedTooltip === null || clickedTooltip === void 0 ? void 0 : clickedTooltip.closeOnClick) {\n        this.toggleTooltip(clickedTooltip, false);\n        this.clearHoverTimeout(clickedTooltip);\n      }\n    };\n    this.focusShow = (event) => {\n      this.focusEvent(event, true);\n    };\n    this.blurHide = (event) => {\n      this.focusEvent(event, false);\n    };\n    this.hoverToggle = (tooltip, value) => {\n      const { hoverTimeouts } = this;\n      hoverTimeouts.delete(tooltip);\n      if (value) {\n        this.closeExistingTooltip();\n      }\n      this.toggleTooltip(tooltip, value);\n    };\n  }\n  // --------------------------------------------------------------------------\n  //\n  //  Public Methods\n  //\n  // --------------------------------------------------------------------------\n  registerElement(referenceEl, tooltip) {\n    this.registeredElementCount++;\n    this.registeredElements.set(referenceEl, tooltip);\n    if (this.registeredElementCount === 1) {\n      this.addListeners();\n    }\n  }\n  unregisterElement(referenceEl) {\n    if (this.registeredElements.delete(referenceEl)) {\n      this.registeredElementCount--;\n    }\n    if (this.registeredElementCount === 0) {\n      this.removeListeners();\n    }\n  }\n  addListeners() {\n    document.addEventListener(\"keydown\", this.keyDownHandler);\n    document.addEventListener(\"pointerover\", this.mouseEnterShow, { capture: true });\n    document.addEventListener(\"pointerout\", this.mouseLeaveHide, { capture: true });\n    document.addEventListener(\"pointerdown\", this.clickHandler, { capture: true });\n    document.addEventListener(\"focusin\", this.focusShow, { capture: true });\n    document.addEventListener(\"focusout\", this.blurHide, { capture: true });\n  }\n  removeListeners() {\n    document.removeEventListener(\"keydown\", this.keyDownHandler);\n    document.removeEventListener(\"pointerover\", this.mouseEnterShow, { capture: true });\n    document.removeEventListener(\"pointerout\", this.mouseLeaveHide, { capture: true });\n    document.removeEventListener(\"pointerdown\", this.clickHandler, { capture: true });\n    document.removeEventListener(\"focusin\", this.focusShow, { capture: true });\n    document.removeEventListener(\"focusout\", this.blurHide, { capture: true });\n  }\n  clearHoverTimeout(tooltip) {\n    const { hoverTimeouts } = this;\n    if (hoverTimeouts.has(tooltip)) {\n      window.clearTimeout(hoverTimeouts.get(tooltip));\n      hoverTimeouts.delete(tooltip);\n    }\n  }\n  closeExistingTooltip() {\n    const { activeTooltipEl } = this;\n    if (activeTooltipEl) {\n      this.toggleTooltip(activeTooltipEl, false);\n    }\n  }\n  focusTooltip(tooltip, value) {\n    this.closeExistingTooltip();\n    if (value) {\n      this.clearHoverTimeout(tooltip);\n    }\n    this.toggleTooltip(tooltip, value);\n  }\n  toggleTooltip(tooltip, value) {\n    tooltip.open = value;\n    if (value) {\n      this.activeTooltipEl = tooltip;\n    }\n  }\n  hoverTooltip(tooltip, value) {\n    this.clearHoverTimeout(tooltip);\n    const { hoverTimeouts } = this;\n    const timeoutId = window.setTimeout(() => this.hoverToggle(tooltip, value), TOOLTIP_DELAY_MS );\n    hoverTimeouts.set(tooltip, timeoutId);\n  }\n  activeTooltipHover(event) {\n    const { activeTooltipEl, hoverTimeouts } = this;\n    const { type } = event;\n    if (!activeTooltipEl) {\n      return;\n    }\n    if (type === \"pointerover\" && event.composedPath().includes(activeTooltipEl)) {\n      this.clearHoverTimeout(activeTooltipEl);\n    }\n    else if (type === \"pointerout\" && !hoverTimeouts.has(activeTooltipEl)) {\n      this.hoverTooltip(activeTooltipEl, false);\n    }\n  }\n  hoverEvent(event, value) {\n    const tooltip = this.queryTooltip(event.composedPath());\n    this.activeTooltipHover(event);\n    if (!tooltip) {\n      return;\n    }\n    this.hoverTooltip(tooltip, value);\n  }\n  focusEvent(event, value) {\n    const tooltip = this.queryTooltip(event.composedPath());\n    if (!tooltip || tooltip === this.clickedTooltip) {\n      this.clickedTooltip = null;\n      return;\n    }\n    this.focusTooltip(tooltip, value);\n  }\n}\n\nconst tooltipCss = \"@keyframes in{0%{opacity:0}100%{opacity:1}}@keyframes in-down{0%{opacity:0;transform:translate3D(0, -5px, 0)}100%{opacity:1;transform:translate3D(0, 0, 0)}}@keyframes in-up{0%{opacity:0;transform:translate3D(0, 5px, 0)}100%{opacity:1;transform:translate3D(0, 0, 0)}}@keyframes in-scale{0%{opacity:0;transform:scale3D(0.95, 0.95, 1)}100%{opacity:1;transform:scale3D(1, 1, 1)}}:root{--calcite-animation-timing:calc(150ms * var(--calcite-internal-duration-factor));--calcite-internal-duration-factor:var(--calcite-duration-factor, 1);--calcite-internal-animation-timing-fast:calc(100ms * var(--calcite-internal-duration-factor));--calcite-internal-animation-timing-medium:calc(200ms * var(--calcite-internal-duration-factor));--calcite-internal-animation-timing-slow:calc(300ms * var(--calcite-internal-duration-factor))}.calcite-animate{opacity:0;animation-fill-mode:both;animation-duration:var(--calcite-animation-timing)}.calcite-animate__in{animation-name:in}.calcite-animate__in-down{animation-name:in-down}.calcite-animate__in-up{animation-name:in-up}.calcite-animate__in-scale{animation-name:in-scale}@media (prefers-reduced-motion: reduce){:root{--calcite-internal-duration-factor:0.01}}:root{--calcite-floating-ui-transition:var(--calcite-animation-timing)}:host([hidden]){display:none}:host{display:block;position:absolute;z-index:999}.calcite-floating-ui-anim{position:relative;transition:var(--calcite-floating-ui-transition);visibility:hidden;transition-property:transform, visibility, opacity;opacity:0;box-shadow:0 0 16px 0 rgba(0, 0, 0, 0.16);z-index:1;border-radius:0.25rem}:host([data-placement^=bottom]) .calcite-floating-ui-anim{transform:translateY(-5px)}:host([data-placement^=top]) .calcite-floating-ui-anim{transform:translateY(5px)}:host([data-placement^=left]) .calcite-floating-ui-anim{transform:translateX(5px)}:host([data-placement^=right]) .calcite-floating-ui-anim{transform:translateX(-5px)}:host([data-placement]) .calcite-floating-ui-anim--active{opacity:1;visibility:visible;transform:translate(0)}:host([calcite-hydrated-hidden]){visibility:hidden !important;pointer-events:none}.arrow,.arrow::before{position:absolute;inline-size:8px;block-size:8px;z-index:-1}.arrow::before{content:\\\"\\\";--tw-shadow:0 4px 8px -1px rgba(0, 0, 0, 0.08), 0 2px 4px -1px rgba(0, 0, 0, 0.04);--tw-shadow-colored:0 4px 8px -1px var(--tw-shadow-color), 0 2px 4px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);transform:rotate(45deg);background:var(--calcite-ui-foreground-1)}:host([data-placement^=top]) .arrow{inset-block-end:-4px}:host([data-placement^=bottom]) .arrow{inset-block-start:-4px}:host([data-placement^=left]) .arrow{direction:ltr;inset-inline-end:-4px}:host([data-placement^=right]) .arrow{direction:ltr;inset-inline-start:-4px}.container{position:relative;overflow:hidden;border-radius:0.25rem;background-color:var(--calcite-ui-foreground-1);padding-block:0.75rem;padding-inline:1rem;font-size:var(--calcite-font-size--2);line-height:1.375;font-weight:var(--calcite-font-weight-medium);color:var(--calcite-ui-text-1);max-inline-size:20rem;max-block-size:20rem;text-align:start}.calcite-floating-ui-anim{border-radius:0.25rem;border-width:1px;border-style:solid;border-color:var(--calcite-ui-border-3);background-color:var(--calcite-ui-foreground-1)}.arrow::before{outline:1px solid var(--calcite-ui-border-3)}\";\n\nconst manager = new TooltipManager();\nconst Tooltip = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {\n  constructor() {\n    super();\n    this.__registerHost();\n    this.__attachShadow();\n    // --------------------------------------------------------------------------\n    //\n    //  Properties\n    //\n    // --------------------------------------------------------------------------\n    /** Closes the component when the `referenceElement` is clicked. */\n    this.closeOnClick = false;\n    /**\n     * Offset the position of the component away from the `referenceElement`.\n     *\n     * @default 6\n     */\n    this.offsetDistance = defaultOffsetDistance;\n    /**\n     * Offset the position of the component along the `referenceElement`.\n     */\n    this.offsetSkidding = 0;\n    /**\n     * When `true`, the component is open.\n     */\n    this.open = false;\n    /**\n     * Determines the type of positioning to use for the overlaid content.\n     *\n     * Using `\"absolute\"` will work for most cases. The component will be positioned inside of overflowing parent containers and will affect the container's layout.\n     *\n     * The `\"fixed\"` value should be used to escape an overflowing parent container, or when the reference element's `position` CSS property is `\"fixed\"`.\n     *\n     */\n    this.overlayPositioning = \"absolute\";\n    /**\n     * Determines where the component will be positioned relative to the `referenceElement`.\n     *\n     * @see [LogicalPlacement](https://github.com/Esri/calcite-components/blob/master/src/utils/floating-ui.ts#L25)\n     */\n    this.placement = \"auto\";\n    this.guid = `calcite-tooltip-${guid()}`;\n    this.hasLoaded = false;\n    // --------------------------------------------------------------------------\n    //\n    //  Private Methods\n    //\n    // --------------------------------------------------------------------------\n    this.setUpReferenceElement = (warn = true) => {\n      this.removeReferences();\n      this.effectiveReferenceElement = this.getReferenceElement();\n      connectFloatingUI(this, this.effectiveReferenceElement, this.el);\n      const { el, referenceElement, effectiveReferenceElement } = this;\n      if (warn && referenceElement && !effectiveReferenceElement) {\n        console.warn(`${el.tagName}: reference-element id \"${referenceElement}\" was not found.`, {\n          el\n        });\n      }\n      this.addReferences();\n    };\n    this.getId = () => {\n      return this.el.id || this.guid;\n    };\n    this.addReferences = () => {\n      const { effectiveReferenceElement } = this;\n      if (!effectiveReferenceElement) {\n        return;\n      }\n      const id = this.getId();\n      if (\"setAttribute\" in effectiveReferenceElement) {\n        effectiveReferenceElement.setAttribute(ARIA_DESCRIBED_BY, id);\n      }\n      manager.registerElement(effectiveReferenceElement, this.el);\n    };\n    this.removeReferences = () => {\n      const { effectiveReferenceElement } = this;\n      if (!effectiveReferenceElement) {\n        return;\n      }\n      if (\"removeAttribute\" in effectiveReferenceElement) {\n        effectiveReferenceElement.removeAttribute(ARIA_DESCRIBED_BY);\n      }\n      manager.unregisterElement(effectiveReferenceElement);\n    };\n  }\n  offsetDistanceOffsetHandler() {\n    this.reposition(true);\n  }\n  offsetSkiddingHandler() {\n    this.reposition(true);\n  }\n  openHandler(value) {\n    if (value) {\n      this.reposition(true);\n    }\n    else {\n      updateAfterClose(this.el);\n    }\n  }\n  overlayPositioningHandler() {\n    this.reposition(true);\n  }\n  placementHandler() {\n    this.reposition(true);\n  }\n  referenceElementHandler() {\n    this.setUpReferenceElement();\n  }\n  // --------------------------------------------------------------------------\n  //\n  //  Lifecycle\n  //\n  // --------------------------------------------------------------------------\n  connectedCallback() {\n    this.setUpReferenceElement(this.hasLoaded);\n  }\n  componentDidLoad() {\n    if (this.referenceElement && !this.effectiveReferenceElement) {\n      this.setUpReferenceElement();\n    }\n    this.reposition(true);\n    this.hasLoaded = true;\n  }\n  disconnectedCallback() {\n    this.removeReferences();\n    disconnectFloatingUI(this, this.effectiveReferenceElement, this.el);\n  }\n  // --------------------------------------------------------------------------\n  //\n  //  Public Methods\n  //\n  // --------------------------------------------------------------------------\n  /**\n   * Updates the position of the component.\n   *\n   * @param delayed\n   */\n  async reposition(delayed = false) {\n    const { el, effectiveReferenceElement, placement, overlayPositioning, offsetDistance, offsetSkidding, arrowEl } = this;\n    return reposition(this, {\n      floatingEl: el,\n      referenceEl: effectiveReferenceElement,\n      overlayPositioning,\n      placement,\n      offsetDistance,\n      offsetSkidding,\n      includeArrow: true,\n      arrowEl,\n      type: \"tooltip\"\n    }, delayed);\n  }\n  getReferenceElement() {\n    const { referenceElement, el } = this;\n    return ((typeof referenceElement === \"string\"\n      ? queryElementRoots(el, { id: referenceElement })\n      : referenceElement) || null);\n  }\n  // --------------------------------------------------------------------------\n  //\n  //  Render Methods\n  //\n  // --------------------------------------------------------------------------\n  render() {\n    const { effectiveReferenceElement, label, open } = this;\n    const displayed = effectiveReferenceElement && open;\n    const hidden = !displayed;\n    return (h(Host, { \"aria-hidden\": toAriaBoolean(hidden), \"aria-label\": label, \"aria-live\": \"polite\", \"calcite-hydrated-hidden\": hidden, id: this.getId(), role: \"tooltip\" }, h(\"div\", { class: {\n        [FloatingCSS.animation]: true,\n        [FloatingCSS.animationActive]: displayed\n      } }, h(\"div\", { class: CSS.arrow, ref: (arrowEl) => (this.arrowEl = arrowEl) }), h(\"div\", { class: CSS.container }, h(\"slot\", null)))));\n  }\n  get el() { return this; }\n  static get watchers() { return {\n    \"offsetDistance\": [\"offsetDistanceOffsetHandler\"],\n    \"offsetSkidding\": [\"offsetSkiddingHandler\"],\n    \"open\": [\"openHandler\"],\n    \"overlayPositioning\": [\"overlayPositioningHandler\"],\n    \"placement\": [\"placementHandler\"],\n    \"referenceElement\": [\"referenceElementHandler\"]\n  }; }\n  static get style() { return tooltipCss; }\n}, [1, \"calcite-tooltip\", {\n    \"closeOnClick\": [516, \"close-on-click\"],\n    \"label\": [1],\n    \"offsetDistance\": [514, \"offset-distance\"],\n    \"offsetSkidding\": [514, \"offset-skidding\"],\n    \"open\": [516],\n    \"overlayPositioning\": [513, \"overlay-positioning\"],\n    \"placement\": [513],\n    \"referenceElement\": [1, \"reference-element\"],\n    \"effectiveReferenceElement\": [32],\n    \"reposition\": [64]\n  }]);\nfunction defineCustomElement() {\n  if (typeof customElements === \"undefined\") {\n    return;\n  }\n  const components = [\"calcite-tooltip\"];\n  components.forEach(tagName => { switch (tagName) {\n    case \"calcite-tooltip\":\n      if (!customElements.get(tagName)) {\n        customElements.define(tagName, Tooltip);\n      }\n      break;\n  } });\n}\ndefineCustomElement();\n\nexport { Tooltip as T, defineCustomElement as d };\n"],"sourceRoot":""}