import { unsafeCSS, LitElement, html } from "lit";
import { property, state, queryAssignedElements } from "lit/decorators.js";
import { classMap } from "lit/directives/class-map.js";
import componentStyle from "./poi-group.css.js";
import "../poi-data/poi-data.js";
import { isPoi, PoiDataVisualRectPreference, ObcPoiValue } from "../building-blocks/poi/poi.js";
import { ObcPoiButtonType } from "../building-blocks/poi-button/poi-button.js";
import { customElement } from "../../decorator.js";
import { AnimationManager, frameLerp, easeInOutQuad } from "./animation-utils.js";
import { getEffectivePoiX } from "../building-blocks/poi/poi-position.js";
import "../building-blocks/poi/poi-base.js";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __decorateClass = (decorators, target, key, kind) => {
  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
  for (var i = decorators.length - 1, decorator; i >= 0; i--)
    if (decorator = decorators[i])
      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
  if (kind && result) __defProp(target, key, result);
  return result;
};
const POI_TOUCH_TARGET_VAR = "--maneuvering-components-poi-button-touch-target";
const POI_GROUP_SPACING_VAR = "--obc-poi-group-expanded-spacing";
const TOP_OFFSET_ANIMATION_MS_VAR = "--obc-poi-group-top-offset-animation-ms";
const TOP_OFFSET_ANIMATION_DELAY_MS_VAR = "--obc-poi-group-top-offset-animation-delay-ms";
const POI_VISUAL_TARGET_VAR = "--maneuvering-components-poi-button-visual-target-round";
const POI_VISUAL_TARGET_OVERLAP_VAR = "--maneuvering-components-poi-button-visual-target-round-overlap";
const POI_LARGE_VISUAL_TARGET_VAR = "--maneuvering-components-poi-button-large-visual-target-round";
const POI_LARGE_VISUAL_TARGET_OVERLAP_VAR = "--maneuvering-components-poi-button-large-visual-target-round-overlap";
let ObcPoiGroup = class extends LitElement {
  constructor() {
    super();
    this.expand = false;
    this.collapsing = false;
    this.positionVertical = "0px";
    this.internalSwapping = false;
    this.wrapperOffsetX = "0px";
    this.wrapperWidth = "48px";
    this.wrapperVisible = false;
    this.wrapperHeight = "48px";
    this.wrapperHasValues = false;
    this.topOffsetAnimationManager = new AnimationManager();
    this.topOffsetProgress = 0;
    this.slotChangeRaf = 0;
    this.topOffsetTargets = /* @__PURE__ */ new Map();
    this.lockedExpandedCenter = null;
    this.collapseDeltas = /* @__PURE__ */ new Map();
    this.topOffsetAnimationTarget = null;
    this.onSlotChange = () => {
      if (this.slotChangeRaf) {
        cancelAnimationFrame(this.slotChangeRaf);
      }
      this.slotChangeRaf = requestAnimationFrame(() => {
        this.slotChangeRaf = 0;
        this.updatePosition();
        if (!this.expand) {
          this.ensureFrontChildOnTop();
          this.syncFrontChild();
        }
      });
    };
    this.topOffsetDelayTimeout = null;
    this.expandedLoopRunning = false;
    this.lastAppliedOffsets = /* @__PURE__ */ new Map();
    this.lastTargetOrder = [];
    this.boundUpdatePosition = this.updatePosition.bind(this);
  }
  firstUpdated(_changedProperties) {
    super.firstUpdated(_changedProperties);
    this.updatePosition();
    this.syncFrontChild();
    const slot = this.shadowRoot?.querySelector("slot");
    slot?.addEventListener("slotchange", this.onSlotChange);
    if (!this.expand) {
      this.wrapperVisible = true;
    }
  }
  connectedCallback() {
    super.connectedCallback();
    window.addEventListener("resize", this.boundUpdatePosition);
  }
  disconnectedCallback() {
    const slot = this.shadowRoot?.querySelector("slot");
    slot?.removeEventListener("slotchange", this.onSlotChange);
    window.removeEventListener("resize", this.boundUpdatePosition);
    this.stopExpandedObserver();
    if (this.slotChangeRaf) {
      cancelAnimationFrame(this.slotChangeRaf);
      this.slotChangeRaf = 0;
    }
    this.topOffsetAnimationManager.cancel();
    if (this.topOffsetDelayTimeout) {
      clearTimeout(this.topOffsetDelayTimeout);
      this.topOffsetDelayTimeout = null;
    }
    super.disconnectedCallback();
  }
  updated(changedProperties) {
    super.updated(changedProperties);
    if (changedProperties.has("expand")) {
      if (this.collapsing && this.expand) {
        this.expand = false;
        return;
      }
      this.setExpandedChildren(this.expand);
    }
  }
  willUpdate(changedProperties) {
    super.willUpdate(changedProperties);
    if (changedProperties.has("expand") && !this.expand && this.topOffsetProgress > 0) {
      this.wrapperVisible = false;
    }
  }
  onBackdropClick(event) {
    event.stopPropagation();
    this.expand = false;
  }
  render() {
    return html`
      ${this.expand ? html`<div @click=${this.onBackdropClick} class="backdrop"></div>` : null}
      <slot></slot>
      ${!this.expand && this.wrapperVisible ? html`<button
            @click=${this.onClick}
            class=${classMap({
      wrapper: true,
      "with-values": this.wrapperHasValues
    })}
            style="left: 0; top: ${this.positionVertical}; width: ${this.wrapperWidth}; height: ${this.wrapperHeight}; --obc-poi-group-wrapper-x: ${this.wrapperOffsetX};"
          >
            <div class="visible-wrapper"></div>
          </button>` : null}
    `;
  }
  updatePosition() {
    if (this.expand || this.collapsing) {
      return;
    }
    let left = Number.MAX_VALUE;
    let right = -Number.MAX_VALUE;
    let maxHeight = 0;
    let hasValueTargets = false;
    this._children.forEach((element) => {
      if (isPoi(element)) {
        const anchorRect = this.getTargetButtonRect(
          element,
          PoiDataVisualRectPreference.Anchor
        );
        const sizeRect = this.getTargetButtonRect(
          element,
          PoiDataVisualRectPreference.Group
        );
        left = Math.min(left, anchorRect.left);
        right = Math.max(right, anchorRect.right);
        maxHeight = Math.max(maxHeight, sizeRect.height || 0);
        if (Array.isArray(element.data) && element.data.length > 0) {
          hasValueTargets = true;
        }
        return;
      }
      const boundingBox = element.getBoundingClientRect();
      left = Math.min(left, boundingBox.left);
      right = Math.max(right, boundingBox.right);
      maxHeight = Math.max(maxHeight, boundingBox.height || 0);
    });
    if (left !== Number.MAX_VALUE && right !== -Number.MAX_VALUE) {
      const rootDim = this.getBoundingClientRect();
      const targetLeftPx = left - rootDim.left;
      const targetRightPx = right - rootDim.left;
      const targetWidth = Math.max(0, targetRightPx - targetLeftPx);
      this.wrapperOffsetX = `${targetLeftPx}px`;
      this.wrapperWidth = `${targetWidth}px`;
      const normalizedHeight = Number.isFinite(maxHeight) ? Math.max(48, Math.round(maxHeight)) : 48;
      this.wrapperHeight = `${normalizedHeight}px`;
      this.wrapperHasValues = hasValueTargets;
    } else {
      this.wrapperOffsetX = "0px";
      this.wrapperWidth = "48px";
      this.wrapperHeight = "48px";
      this.wrapperHasValues = false;
    }
  }
  ensureFrontChildOnTop() {
    const frontChild = this.getFrontChild();
    if (frontChild && this.lastElementChild !== frontChild) {
      this.appendChild(frontChild);
    }
  }
  onClick() {
    if (this.expand) return;
    if (this.hasAttribute("data-exiting")) return;
    const hasTargets = this._children.some((child) => isPoi(child));
    if (!hasTargets) return;
    this.expand = true;
  }
  setExpandedChildren(expand) {
    this.dispatchEvent(
      new CustomEvent("expand", {
        detail: { expand: this.expand },
        bubbles: true,
        composed: true
      })
    );
    const frontChild = this.getFrontChild();
    if (expand) {
      this.calculateTopOffsetTargets();
    }
    if (!expand) {
      if (this.topOffsetProgress > 0) {
        this.wrapperVisible = false;
      }
      this.lockedExpandedCenter = null;
    }
    if (!expand && frontChild) {
      this.appendChild(frontChild);
    }
    this.animateTopOffset(expand ? 1 : 0);
  }
  calculateTopOffsetTargets(preserveCenter = false) {
    this.topOffsetTargets.clear();
    const targets = this._children.filter(
      (child) => isPoi(child)
    );
    if (targets.length === 0) return;
    const positions = targets.map((child) => {
      const rect = this.getTargetButtonRect(child);
      const currentLeft = this.getCurrentLeft(child);
      return {
        child,
        currentLeft,
        centerX: currentLeft + rect.width / 2,
        width: rect.width
      };
    });
    positions.sort((a, b) => a.currentLeft - b.currentLeft);
    const leftMost = positions[0].centerX;
    const rightMost = positions[positions.length - 1].centerX;
    const computedCenter = (leftMost + rightMost) / 2;
    const groupCenter = preserveCenter && this.lockedExpandedCenter !== null ? this.lockedExpandedCenter : computedCenter;
    if (!preserveCenter) {
      this.lockedExpandedCenter = groupCenter;
    }
    const spacing = this.getExpandedSpacing();
    const totalWidth = (positions.length - 1) * spacing;
    const startX = groupCenter - totalWidth / 2;
    positions.forEach((pos, index) => {
      const targetX = startX + index * spacing;
      const expandedOffset = targetX - pos.centerX;
      const originalLeft = pos.currentLeft;
      this.topOffsetTargets.set(pos.child, {
        originalX: pos.centerX,
        expandedOffset,
        currentExpandedOffset: expandedOffset,
        originalLeft
      });
    });
  }
  refreshExpandedLayout(preserveCenter = false) {
    if (!this.expand) return;
    this.calculateTopOffsetTargets(preserveCenter);
    this.applyTopOffsetState(this.topOffsetProgress, this.getFrontChild());
    this.scheduleExpandedOffsets();
  }
  animateTopOffset(targetProgress) {
    const normalizedTarget = targetProgress === 1 ? 1 : 0;
    const hasPendingOrRunningAnimation = this.topOffsetAnimationManager.isRunning() || this.topOffsetDelayTimeout !== null;
    if (hasPendingOrRunningAnimation && this.topOffsetAnimationTarget === normalizedTarget) {
      return;
    }
    if (!hasPendingOrRunningAnimation && Math.abs(this.topOffsetProgress - normalizedTarget) < 1e-3) {
      return;
    }
    this.topOffsetAnimationTarget = normalizedTarget;
    this.topOffsetAnimationManager.cancel();
    if (this.topOffsetDelayTimeout) {
      clearTimeout(this.topOffsetDelayTimeout);
      this.topOffsetDelayTimeout = null;
    }
    if (targetProgress === 0 && this.topOffsetProgress > 0) {
      this.collapsing = true;
    } else {
      this.collapsing = false;
    }
    const frontChild = this.getFrontChild();
    const isCollapsing = targetProgress === 0 && this.topOffsetProgress > 0;
    if (isCollapsing) {
      this.collapseDeltas.clear();
      this.topOffsetTargets.forEach((config, child) => {
        const currentLeft = this.getCurrentLeft(child);
        const delta = currentLeft - config.originalLeft;
        this.collapseDeltas.set(child, delta);
      });
      const delayMs = this.getCssVarAsNumber(
        TOP_OFFSET_ANIMATION_DELAY_MS_VAR,
        0
      );
      if (delayMs > 0) {
        this.topOffsetDelayTimeout = setTimeout(() => {
          this.topOffsetDelayTimeout = null;
          this.runTopOffsetAnimation(targetProgress, frontChild);
        }, delayMs);
      } else {
        this.runTopOffsetAnimation(targetProgress, frontChild);
      }
    } else {
      if (targetProgress === 1) {
        this.collapseDeltas.clear();
      }
      this.runTopOffsetAnimation(targetProgress, frontChild);
    }
  }
  runTopOffsetAnimation(targetProgress, frontChild) {
    const duration = this.getCssVarAsNumber(TOP_OFFSET_ANIMATION_MS_VAR, 100);
    this.topOffsetAnimationManager.start(
      targetProgress,
      this.topOffsetProgress,
      {
        duration,
        onUpdate: (progress) => {
          this.topOffsetProgress = progress;
          if (targetProgress === 1) {
            this.updateExpandedOffsets(true);
          }
          this.applyTopOffsetState(progress, frontChild);
        },
        onComplete: () => {
          this.topOffsetAnimationTarget = null;
          if (targetProgress === 0) {
            this.collapsing = false;
            this.dispatchEvent(
              new CustomEvent("collapse-finished", {
                bubbles: true,
                composed: true
              })
            );
            this.updatePosition();
            this.wrapperVisible = true;
            this.stopExpandedObserver();
            this.collapseDeltas.clear();
            this.lastTargetOrder = [];
            this.lastAppliedOffsets.clear();
          }
          if (targetProgress === 1) {
            this.startExpandedObserver();
            this.scheduleExpandedOffsets();
          }
        },
        onError: (error) => {
          console.error("[poi-group] Error in top offset animation:", error);
          this.topOffsetAnimationTarget = null;
          this.collapsing = false;
        }
      }
    );
  }
  applyTopOffsetState(progress, frontChild) {
    const eased = easeInOutQuad(progress);
    const frontHeight = frontChild ? this.getTargetButtonRect(frontChild).height : null;
    const visualExpanded = this.collapsing ? false : progress > 0.5;
    const touchAreaExpanded = progress > 0.5;
    this.topOffsetTargets.forEach((config, child) => {
      if (child.parentElement !== this) {
        this.topOffsetTargets.delete(child);
        this.collapseDeltas.delete(child);
        this.lastAppliedOffsets.delete(child);
        return;
      }
      const isCollapsing = this.collapseDeltas.size > 0;
      let delta;
      if (isCollapsing) {
        delta = this.collapseDeltas.get(child) ?? 0;
      } else {
        const currentLeft = this.getCurrentLeft(child);
        delta = currentLeft - config.originalLeft;
      }
      const buttonOffsetX = (config.currentExpandedOffset - delta) * eased;
      child.buttonOffsetX = buttonOffsetX;
      if (child !== frontChild) {
        const isOverlap = !visualExpanded;
        const nextValue = this.resolveTargetValue(child, isOverlap);
        child.value = nextValue;
        if (nextValue === ObcPoiValue.Overlapped) {
          this.applyVisualState(child, true);
        } else {
          this.clearVisualState(child);
        }
        this.setOverlappedDataHeight(
          child,
          nextValue === ObcPoiValue.Overlapped,
          frontHeight
        );
      } else {
        child.value = this.resolveTargetValue(child, false);
        this.clearVisualState(child);
        this.setOverlappedDataHeight(child, false, frontHeight);
      }
      if (touchAreaExpanded) {
        const touchTarget = `${this.getTouchTargetSize()}px`;
        child.style.width = touchTarget;
        child.style.minWidth = touchTarget;
        child.style.height = touchTarget;
      } else {
        child.style.width = "unset";
        child.style.minWidth = "unset";
        child.style.height = "unset";
      }
    });
  }
  getFrontChild() {
    const targets = this._children.filter(
      (child) => isPoi(child)
    );
    if (targets.length === 0) return null;
    let front = null;
    let maxHeight = Number.NEGATIVE_INFINITY;
    const frontByAttr = targets.find(
      (child) => child.hasAttribute("data-front")
    );
    const epsilon = 1e-3;
    for (const child of targets) {
      const yValue = typeof child.y === "number" && Number.isFinite(child.y) ? child.y : Number.parseFloat(child.getAttribute("y") ?? "");
      if (Number.isNaN(yValue)) continue;
      if (yValue > maxHeight + epsilon) {
        maxHeight = yValue;
        front = child;
        continue;
      }
      if (Math.abs(yValue - maxHeight) <= epsilon && frontByAttr && child === frontByAttr) {
        front = child;
      }
    }
    return front ?? targets[0] ?? null;
  }
  syncFrontChild() {
    const front = this.getFrontChild();
    const frontHeight = front ? this.getTargetButtonRect(front).height : null;
    this._children.forEach((child) => {
      if (!isPoi(child)) return;
      const isOverlap = !this.expand && (!front || child !== front);
      const nextValue = this.resolveTargetValue(child, isOverlap);
      child.value = nextValue;
      if (nextValue === ObcPoiValue.Overlapped) {
        this.applyVisualState(child, true);
      } else {
        this.clearVisualState(child);
      }
      if (front && child === front) {
        child.setAttribute("data-front", "true");
      } else {
        child.removeAttribute("data-front");
      }
      this.setOverlappedDataHeight(
        child,
        nextValue === ObcPoiValue.Overlapped,
        frontHeight
      );
    });
  }
  startExpandedObserver() {
    if (this.expandedLoopRunning) return;
    this.expandedLoopRunning = true;
    this.runExpandedLoop();
  }
  runExpandedLoop() {
    if (!this.expandedLoopRunning || !this.expand) {
      this.expandedLoopRunning = false;
      return;
    }
    try {
      this.updateExpandedOffsets();
      requestAnimationFrame(() => this.runExpandedLoop());
    } catch (error) {
      console.error("[poi-group] Error in expanded loop:", error);
      this.expandedLoopRunning = false;
    }
  }
  stopExpandedObserver() {
    this.expandedLoopRunning = false;
    this.lastAppliedOffsets.clear();
    this.lastTargetOrder = [];
  }
  scheduleExpandedOffsets() {
    if (!this.expand) return;
    this.updateExpandedOffsets();
  }
  updateExpandedOffsets(snap = false) {
    if (!this.expand) return;
    const targets = this._children.filter(
      (child) => isPoi(child)
    );
    const sortedByCurrentPosition = [...targets].map((child) => {
      const currentLeft = this.getCurrentLeft(child);
      return { child, currentLeft };
    }).sort((a, b) => a.currentLeft - b.currentLeft).map((item) => item.child);
    const orderedTargets = this.internalSwapping ? sortedByCurrentPosition : this.lastTargetOrder.length > 0 ? this.lastTargetOrder : sortedByCurrentPosition;
    const orderChanged = this.lastTargetOrder.length !== orderedTargets.length || orderedTargets.some(
      (child, index) => this.lastTargetOrder[index] !== child
    );
    if (this.internalSwapping && orderChanged && this.lastTargetOrder.length > 0) {
      const spacing = this.getExpandedSpacing();
      const totalWidth = (orderedTargets.length - 1) * spacing;
      const groupCenter = this.lockedExpandedCenter ?? (() => {
        const positions = orderedTargets.map((child) => {
          return this.getCurrentLeft(child);
        });
        const leftMost = Math.min(...positions);
        const rightMost = Math.max(...positions);
        return (leftMost + rightMost) / 2;
      })();
      if (this.lockedExpandedCenter === null) {
        this.lockedExpandedCenter = groupCenter;
      }
      const startX = groupCenter - totalWidth / 2;
      orderedTargets.forEach((child, index) => {
        const config = this.topOffsetTargets.get(child);
        if (!config) return;
        const targetX = startX + index * spacing;
        const newExpandedOffset = targetX - config.originalX;
        config.expandedOffset = newExpandedOffset;
      });
    }
    this.lastTargetOrder = orderedTargets;
    targets.forEach((child) => {
      if (child.parentElement !== this) {
        this.topOffsetTargets.delete(child);
        this.lastAppliedOffsets.delete(child);
        return;
      }
      const config = this.topOffsetTargets.get(child);
      if (!config) return;
      const currentLeft = this.getCurrentLeft(child);
      const delta = currentLeft - config.originalLeft;
      if (snap) {
        config.currentExpandedOffset = config.expandedOffset;
      } else {
        config.currentExpandedOffset = frameLerp(
          config.currentExpandedOffset,
          config.expandedOffset,
          0.1
        );
      }
      const buttonOffsetX = config.currentExpandedOffset - delta;
      const last = this.lastAppliedOffsets.get(child);
      if (last && last.buttonOffsetX === buttonOffsetX) {
        return;
      }
      this.lastAppliedOffsets.set(child, { buttonOffsetX });
      child.buttonOffsetX = buttonOffsetX;
    });
  }
  getCurrentLeft(element) {
    const computedLeft = getEffectivePoiX(element);
    const transformOffset = Number.parseFloat(
      getComputedStyle(element).getPropertyValue("--obc-poi-target-offset-x")
    );
    return computedLeft + (Number.isFinite(transformOffset) ? transformOffset : 0);
  }
  getTargetButtonRect(target, preference = PoiDataVisualRectPreference.Group) {
    return target.getVisualRect(preference);
  }
  getCssVarAsNumber(varName, fallback) {
    const raw = getComputedStyle(this).getPropertyValue(varName).trim();
    const parsed = Number.parseFloat(raw);
    return Number.isFinite(parsed) ? parsed : fallback;
  }
  getTouchTargetSize() {
    return this.getCssVarAsNumber(POI_TOUCH_TARGET_VAR, 48);
  }
  getExpandedSpacing() {
    const baseSpacing = this.getCssVarAsNumber(POI_GROUP_SPACING_VAR, 50);
    return this.wrapperHasValues ? baseSpacing + 2 : baseSpacing;
  }
  getVisualTargetSize(isEnhanced, isOverlap) {
    if (isEnhanced) {
      return isOverlap ? this.getCssVarAsNumber(POI_LARGE_VISUAL_TARGET_OVERLAP_VAR, 36) : this.getCssVarAsNumber(POI_LARGE_VISUAL_TARGET_VAR, 52);
    }
    return isOverlap ? this.getCssVarAsNumber(POI_VISUAL_TARGET_OVERLAP_VAR, 32) : this.getCssVarAsNumber(POI_VISUAL_TARGET_VAR, 36);
  }
  applyVisualState(target, overlap) {
    const isEnhanced = target.buttonType === ObcPoiButtonType.Enhanced;
    const size = this.getVisualTargetSize(isEnhanced, overlap);
    target.style.setProperty("--poi-size", `${size}px`);
    target.style.setProperty(
      "--obc-poi-target-icon-opacity",
      overlap ? "0" : "1"
    );
    target.style.setProperty("--obc-poi-overlap", overlap ? "1" : "0");
    target.style.setProperty(
      "--obc-poi-overlap-elements-opacity",
      overlap ? "0" : "1"
    );
    target.style.setProperty("--obc-poi-label-opacity", overlap ? "0" : "1");
    target.style.setProperty(
      "--obc-poi-label-visibility",
      overlap ? "hidden" : "visible"
    );
    target.style.setProperty(
      "--obc-poi-overlap-pointer-events",
      overlap ? "none" : "auto"
    );
  }
  clearVisualState(target) {
    target.style.removeProperty("--poi-size");
    target.style.removeProperty("--obc-poi-target-icon-opacity");
    target.style.removeProperty("--obc-poi-overlap");
    target.style.removeProperty("--obc-poi-overlap-elements-opacity");
    target.style.removeProperty("--obc-poi-label-opacity");
    target.style.removeProperty("--obc-poi-label-visibility");
    target.style.removeProperty("--obc-poi-overlap-pointer-events");
  }
  setOverlappedDataHeight(target, overlap, frontHeight) {
    const dataLength = Array.isArray(target.data) ? target.data.length : 0;
    if (!overlap || dataLength === 0 || frontHeight === null || !Number.isFinite(frontHeight)) {
      target.style.removeProperty("--obc-poi-group-overlap-height");
      target.style.removeProperty("--obc-poi-group-overlap-shift");
      return;
    }
    const adjustedHeight = Math.max(0, frontHeight * 0.95);
    const shift = Math.max(0, frontHeight - adjustedHeight);
    target.style.setProperty(
      "--obc-poi-group-overlap-height",
      `${adjustedHeight}px`
    );
    target.style.setProperty("--obc-poi-group-overlap-shift", `${shift}px`);
  }
  resolveTargetValue(target, overlap) {
    if (overlap) {
      return ObcPoiValue.Overlapped;
    }
    if (target.selected) {
      return ObcPoiValue.Checked;
    }
    return ObcPoiValue.Unchecked;
  }
};
ObcPoiGroup.styles = unsafeCSS(componentStyle);
__decorateClass([
  property({ type: Boolean })
], ObcPoiGroup.prototype, "expand", 2);
__decorateClass([
  property({ type: Boolean, reflect: true })
], ObcPoiGroup.prototype, "collapsing", 2);
__decorateClass([
  property({ type: String })
], ObcPoiGroup.prototype, "positionVertical", 2);
__decorateClass([
  property({ type: Boolean, attribute: "internal-swapping" })
], ObcPoiGroup.prototype, "internalSwapping", 2);
__decorateClass([
  state()
], ObcPoiGroup.prototype, "wrapperOffsetX", 2);
__decorateClass([
  state()
], ObcPoiGroup.prototype, "wrapperWidth", 2);
__decorateClass([
  state()
], ObcPoiGroup.prototype, "wrapperVisible", 2);
__decorateClass([
  state()
], ObcPoiGroup.prototype, "wrapperHeight", 2);
__decorateClass([
  state()
], ObcPoiGroup.prototype, "wrapperHasValues", 2);
__decorateClass([
  queryAssignedElements({ flatten: true })
], ObcPoiGroup.prototype, "_children", 2);
ObcPoiGroup = __decorateClass([
  customElement("obc-poi-group")
], ObcPoiGroup);
export {
  ObcPoiGroup
};
//# sourceMappingURL=poi-group.js.map
