{"version":3,"file":"js/9162.c1c9da46.js","mappings":"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","sources":["webpack://alingsas-map/./node_modules/@esri/calcite-components/dist/components/debounce.js","webpack://alingsas-map/./node_modules/@esri/calcite-components/dist/components/floating-ui.js","webpack://alingsas-map/./node_modules/@esri/calcite-components/dist/components/guid.js","webpack://alingsas-map/./node_modules/@esri/calcite-components/dist/components/tooltip.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 */\nfunction gen(counts) {\n  return counts\n    .map((count) => {\n    let out = \"\";\n    for (let i = 0; i < count; i++) {\n      out += (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);\n    }\n    return out;\n  })\n    .join(\"-\");\n}\nconst guid = () => gen([2, 1, 1, 1, 3]);\n\nexport { guid as g };\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"],"names":["freeGlobal","global","Object","freeSelf","self","root","Function","Symbol","objectProto$1","prototype","hasOwnProperty","nativeObjectToString$1","toString","symToStringTag$1","toStringTag","undefined","getRawTag","value","isOwn","call","tag","unmasked","e","result","objectProto","nativeObjectToString","objectToString","nullTag","undefinedTag","symToStringTag","baseGetTag","isObjectLike","symbolTag","isSymbol","reWhitespace","trimmedEndIndex","string","index","length","test","charAt","reTrimStart","baseTrim","slice","replace","isObject","type","NAN","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","toNumber","other","valueOf","isBinary","now","Date","FUNC_ERROR_TEXT","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","remainingWait","timeSinceLastCall","timeSinceLastInvoke","timeWaiting","shouldInvoke","trailingEdge","cancel","clearTimeout","flush","debounced","isInvoking","arguments","this","getSide","placement","split","getAlignment","getMainAxisFromPlacement","includes","getLengthFromAxis","axis","computeCoordsFromPlacement","_ref","rtl","reference","floating","commonX","x","width","commonY","y","height","mainAxis","commonAlign","side","isVertical","coords","computePosition$1","async","config","strategy","middleware","platform","isRTL","rects","getElementRects","statefulPlacement","middlewareData","resetCount","i","name","fn","nextX","nextY","data","reset","initialPlacement","elements","expandPaddingObject","padding","top","right","bottom","left","getSideObjectFromPadding","rectToClientRect","rect","detectOverflow","middlewareArguments","_await$platform$isEle","boundary","rootBoundary","elementContext","altBoundary","paddingObject","altContext","element","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","offsetParent","getOffsetParent","min$1","max$1","within","min$1$1","max$1$1","arrow","alignment","arrowDimensions","getDimensions","minProp","maxProp","endDiff","startDiff","arrowOffsetParent","clientSize","clientHeight","clientWidth","centerToReference","center","offset","alignmentPadding","shouldAddOffset","alignmentOffset","centerOffset","hash$1","getOppositePlacement","matched","getAlignmentSides","mainAlignmentSide","main","cross","hash","start","end","getOppositeAlignmentPlacement","sides","allPlacements","reduce","acc","concat","getPlacementList","autoAlignment","allowedPlacements","allowedPlacementsSortedByAlignment","filter","autoPlacement","_middlewareData$autoP","_middlewareData$autoP2","_middlewareData$autoP3","_middlewareData$autoP4","_placementsSortedByLe","detectOverflowOptions","placements","overflow","currentIndex","currentPlacement","currentOverflows","allOverflows","overflows","nextPlacement","placementsSortedByLeastOverflow","sort","a","b","placementThatFitsOnAllSides","find","every","resetPlacement","getExpandedPlacements","oppositePlacement","flip","_middlewareData$flip","checkMainAxis","crossAxis","checkCrossAxis","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","flipAlignment","isBasePlacement","overflowsData","push","_middlewareData$flip$","_middlewareData$flip2","nextIndex","_overflowsData$map$so","map","d","getSideOffsets","isAnySideFullyClipped","some","hide","_temp","offsets","referenceHiddenOffsets","referenceHidden","escapedOffsets","escaped","convertValueToCoords","mainAxisMulti","crossAxisMulti","rawValue","alignmentAxis","diffCoords","getCrossAxis","shift","limiter","mainAxisCoord","crossAxisCoord","minSide","maxSide","limitedCoords","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","isNode","Node","isShadowRoot","ShadowRoot","OwnElement","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","documentElement","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getWindowScrollBarX","isScaled","getRectRelativeToOffsetParent","isOffsetParentAnElement","scroll","offsetRect","clientLeft","clientTop","getParentNode","assignedSlot","parentNode","host","getTrueOffsetParent","position","getContainingBlock","currentNode","parent","getViewportRect","html","layoutViewport","getDocumentRect","_element$ownerDocumen","body","scrollWidth","scrollHeight","direction","getNearestOverflowAncestor","getOverflowAncestors","list","_node$ownerDocument","scrollableAncestor","isBody","target","updatedList","contains","child","rootNode","getRootNode","next","getNearestParentCapableOfEscapingClipping","clippingAncestors","getInnerBoundingClientRect","getClientRectFromClippingAncestor","clippingParent","getClippingAncestors","nearestEscapableParent","clipperElement","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","placementDataAttribute","repositionDebounceTimeout","effectivePlacements","FloatingCSS","animation","animationActive","getMiddleware","disableFlip","flipPlacements","offsetDistance","offsetSkidding","arrowEl","defaultMiddleware","filterComputedPlacements","el","filteredPlacements","console","warn","tagName","trim","getEffectivePlacement","floatingEl","getElementDir","reverse","reposition","component","delayed","open","debouncedReposition","positionFloatingUI","referenceEl","overlayPositioning","includeArrow","_a","effectivePlacement","arrowX","arrowY","assign","style","visibility","pointerEvents","setAttribute","cleanupMap","WeakMap","connectFloatingUI","disconnectFloatingUI","moveOffScreen","runAutoUpdate","_refEl","_floatingEl","updateCallback","set","getTransitionTarget","handleTransitionElTransitionEnd","cleanup","get","delete","visiblePointerSize","defaultOffsetDistance","ceil","hypot","updateAfterClose","shadowRoot","event","floatingTransitionEl","propertyName","classList","getFloatingElFromTransitionTarget","closestElementCrossShadowBoundary","gen","counts","count","out","random","substring","guid","CSS","container","TOOLTIP_DELAY_MS","ARIA_DESCRIBED_BY","TooltipManager","constructor","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","registerElement","addListeners","unregisterElement","removeListeners","capture","focusTooltip","hoverTooltip","timeoutId","activeTooltipHover","tooltipCss","manager","Tooltip","proxyCustomElement","super","__registerHost","__attachShadow","hasLoaded","setUpReferenceElement","removeReferences","effectiveReferenceElement","getReferenceElement","referenceElement","addReferences","getId","id","removeAttribute","offsetDistanceOffsetHandler","offsetSkiddingHandler","openHandler","overlayPositioningHandler","placementHandler","referenceElementHandler","connectedCallback","componentDidLoad","disconnectedCallback","queryElementRoots","render","label","displayed","hidden","h","Host","toAriaBoolean","role","class","ref","watchers","defineCustomElement","customElements","components","define"],"sourceRoot":""}