var _a;
import { m as ms, j as jsxRuntimeExports, l as useTranslation, k as useWidgetsCore, v as useWidgetsLogger, u as useQueryClient, p as useQuery, L as Loader } from "./root-sLDd8QD-.js";
import { c as castArray, o as omit, u as useTransition, a as useInView, b as useIsOnline, d as useIsFocused, e as adaptivecards, m as mergeRefs, t as textToHtml, f as distExports, g as createAnchor, n as name, R as Root, V as VisuallyHidden, T as Title, C as Content, h as animated, j as Close } from "./conversation-HiDDVXNO.js";
import { B as tw, y as tx, C as css, z as keyframes } from "./core-Cwgs8QYF.js";
import { r as reactExports, g as getDefaultExportFromCjs, R as React, m as merge, ag as isExecuteAction, ah as isOpenUrlAction, ai as isShowCardAction, aj as isSubmitAction, o as objectType, a7 as stringType, ae as literalType, ak as arrayType, a8 as adaptiveCardObjectSchema } from "./index-BSmBSkuE.js";
function ChevronLeftIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /* @__PURE__ */ reactExports.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /* @__PURE__ */ reactExports.createElement("title", {
    id: titleId
  }, title) : null, /* @__PURE__ */ reactExports.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M15.75 19.5 8.25 12l7.5-7.5"
  }));
}
const ForwardRef = /* @__PURE__ */ reactExports.forwardRef(ChevronLeftIcon);
var parseUnit$1 = function parseUnit(str, out) {
  if (!out)
    out = [0, ""];
  str = String(str);
  var num = parseFloat(str, 10);
  out[0] = num;
  out[1] = str.match(/[\d.\-\+]*\s*(.*)/)[1] || "";
  return out;
};
var parseUnit2 = parseUnit$1;
var browser = toPX;
var PIXELS_PER_INCH = getSizeBrutal("in", document.body);
function getPropertyInPX(element, prop) {
  var parts = parseUnit2(getComputedStyle(element).getPropertyValue(prop));
  return parts[0] * toPX(parts[1], element);
}
function getSizeBrutal(unit, element) {
  var testDIV = document.createElement("div");
  testDIV.style["height"] = "128" + unit;
  element.appendChild(testDIV);
  var size = getPropertyInPX(testDIV, "height") / 128;
  element.removeChild(testDIV);
  return size;
}
function toPX(str, element) {
  if (!str) return null;
  element = element || document.body;
  str = (str + "" || "px").trim().toLowerCase();
  if (element === window || element === document) {
    element = document.body;
  }
  switch (str) {
    case "%":
      return element.clientHeight / 100;
    case "ch":
    case "ex":
      return getSizeBrutal(str, element);
    case "em":
      return getPropertyInPX(element, "font-size");
    case "rem":
      return getPropertyInPX(document.body, "font-size");
    case "vw":
      return window.innerWidth / 100;
    case "vh":
      return window.innerHeight / 100;
    case "vmin":
      return Math.min(window.innerWidth, window.innerHeight) / 100;
    case "vmax":
      return Math.max(window.innerWidth, window.innerHeight) / 100;
    case "in":
      return PIXELS_PER_INCH;
    case "cm":
      return PIXELS_PER_INCH / 2.54;
    case "mm":
      return PIXELS_PER_INCH / 25.4;
    case "pt":
      return PIXELS_PER_INCH / 72;
    case "pc":
      return PIXELS_PER_INCH / 6;
    case "px":
      return 1;
  }
  var parts = parseUnit2(str);
  if (!isNaN(parts[0]) && parts[1]) {
    var px = toPX(parts[1], element);
    return typeof px === "number" ? parts[0] * px : null;
  }
  return null;
}
const toPx = /* @__PURE__ */ getDefaultExportFromCjs(browser);
function clamp(v, min, max) {
  return Math.max(min, Math.min(v, max));
}
const V = {
  toVector(v, fallback) {
    if (v === void 0) v = fallback;
    return Array.isArray(v) ? v : [v, v];
  },
  add(v1, v2) {
    return [v1[0] + v2[0], v1[1] + v2[1]];
  },
  sub(v1, v2) {
    return [v1[0] - v2[0], v1[1] - v2[1]];
  },
  addTo(v1, v2) {
    v1[0] += v2[0];
    v1[1] += v2[1];
  },
  subTo(v1, v2) {
    v1[0] -= v2[0];
    v1[1] -= v2[1];
  }
};
function rubberband(distance, dimension, constant) {
  if (dimension === 0 || Math.abs(dimension) === Infinity) return Math.pow(distance, constant * 5);
  return distance * dimension * constant / (dimension + constant * distance);
}
function rubberbandIfOutOfBounds(position, min, max, constant = 0.15) {
  if (constant === 0) return clamp(position, min, max);
  if (position < min) return -rubberband(min - position, max - min, constant) + min;
  if (position > max) return +rubberband(position - max, max - min, constant) + max;
  return position;
}
function computeRubberband(bounds, [Vx, Vy], [Rx, Ry]) {
  const [[X0, X1], [Y0, Y1]] = bounds;
  return [rubberbandIfOutOfBounds(Vx, X0, X1, Rx), rubberbandIfOutOfBounds(Vy, Y0, Y1, Ry)];
}
function _toPrimitive(input, hint) {
  if (typeof input !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== void 0) {
    var res = prim.call(input, hint || "default");
    if (typeof res !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
function _toPropertyKey(arg) {
  var key = _toPrimitive(arg, "string");
  return typeof key === "symbol" ? key : String(key);
}
function _defineProperty(obj, key, value) {
  key = _toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
function ownKeys(e, r) {
  var t = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var o = Object.getOwnPropertySymbols(e);
    r && (o = o.filter(function(r2) {
      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
    })), t.push.apply(t, o);
  }
  return t;
}
function _objectSpread2(e) {
  for (var r = 1; r < arguments.length; r++) {
    var t = null != arguments[r] ? arguments[r] : {};
    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
      _defineProperty(e, r2, t[r2]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
    });
  }
  return e;
}
const EVENT_TYPE_MAP = {
  pointer: {
    start: "down",
    change: "move",
    end: "up"
  },
  mouse: {
    start: "down",
    change: "move",
    end: "up"
  },
  touch: {
    start: "start",
    change: "move",
    end: "end"
  },
  gesture: {
    start: "start",
    change: "change",
    end: "end"
  }
};
function capitalize(string) {
  if (!string) return "";
  return string[0].toUpperCase() + string.slice(1);
}
const actionsWithoutCaptureSupported = ["enter", "leave"];
function hasCapture(capture = false, actionKey) {
  return capture && !actionsWithoutCaptureSupported.includes(actionKey);
}
function toHandlerProp(device, action = "", capture = false) {
  const deviceProps = EVENT_TYPE_MAP[device];
  const actionKey = deviceProps ? deviceProps[action] || action : action;
  return "on" + capitalize(device) + capitalize(actionKey) + (hasCapture(capture, actionKey) ? "Capture" : "");
}
const pointerCaptureEvents = ["gotpointercapture", "lostpointercapture"];
function parseProp(prop) {
  let eventKey = prop.substring(2).toLowerCase();
  const passive = !!~eventKey.indexOf("passive");
  if (passive) eventKey = eventKey.replace("passive", "");
  const captureKey = pointerCaptureEvents.includes(eventKey) ? "capturecapture" : "capture";
  const capture = !!~eventKey.indexOf(captureKey);
  if (capture) eventKey = eventKey.replace("capture", "");
  return {
    device: eventKey,
    capture,
    passive
  };
}
function toDomEventType(device, action = "") {
  const deviceProps = EVENT_TYPE_MAP[device];
  const actionKey = deviceProps ? deviceProps[action] || action : action;
  return device + actionKey;
}
function isTouch(event) {
  return "touches" in event;
}
function getPointerType(event) {
  if (isTouch(event)) return "touch";
  if ("pointerType" in event) return event.pointerType;
  return "mouse";
}
function getCurrentTargetTouchList(event) {
  return Array.from(event.touches).filter((e) => {
    var _event$currentTarget, _event$currentTarget$;
    return e.target === event.currentTarget || ((_event$currentTarget = event.currentTarget) === null || _event$currentTarget === void 0 || (_event$currentTarget$ = _event$currentTarget.contains) === null || _event$currentTarget$ === void 0 ? void 0 : _event$currentTarget$.call(_event$currentTarget, e.target));
  });
}
function getTouchList(event) {
  return event.type === "touchend" || event.type === "touchcancel" ? event.changedTouches : event.targetTouches;
}
function getValueEvent(event) {
  return isTouch(event) ? getTouchList(event)[0] : event;
}
function touchIds(event) {
  return getCurrentTargetTouchList(event).map((touch) => touch.identifier);
}
function pointerId(event) {
  const valueEvent = getValueEvent(event);
  return isTouch(event) ? valueEvent.identifier : valueEvent.pointerId;
}
function pointerValues(event) {
  const valueEvent = getValueEvent(event);
  return [valueEvent.clientX, valueEvent.clientY];
}
function getEventDetails(event) {
  const payload = {};
  if ("buttons" in event) payload.buttons = event.buttons;
  if ("shiftKey" in event) {
    const {
      shiftKey,
      altKey,
      metaKey,
      ctrlKey
    } = event;
    Object.assign(payload, {
      shiftKey,
      altKey,
      metaKey,
      ctrlKey
    });
  }
  return payload;
}
function call(v, ...args) {
  if (typeof v === "function") {
    return v(...args);
  } else {
    return v;
  }
}
function noop() {
}
function chain(...fns) {
  if (fns.length === 0) return noop;
  if (fns.length === 1) return fns[0];
  return function() {
    let result;
    for (const fn of fns) {
      result = fn.apply(this, arguments) || result;
    }
    return result;
  };
}
function assignDefault(value, fallback) {
  return Object.assign({}, fallback, value || {});
}
const BEFORE_LAST_KINEMATICS_DELAY = 32;
class Engine {
  constructor(ctrl, args, key) {
    this.ctrl = ctrl;
    this.args = args;
    this.key = key;
    if (!this.state) {
      this.state = {};
      this.computeValues([0, 0]);
      this.computeInitial();
      if (this.init) this.init();
      this.reset();
    }
  }
  get state() {
    return this.ctrl.state[this.key];
  }
  set state(state) {
    this.ctrl.state[this.key] = state;
  }
  get shared() {
    return this.ctrl.state.shared;
  }
  get eventStore() {
    return this.ctrl.gestureEventStores[this.key];
  }
  get timeoutStore() {
    return this.ctrl.gestureTimeoutStores[this.key];
  }
  get config() {
    return this.ctrl.config[this.key];
  }
  get sharedConfig() {
    return this.ctrl.config.shared;
  }
  get handler() {
    return this.ctrl.handlers[this.key];
  }
  reset() {
    const {
      state,
      shared,
      ingKey,
      args
    } = this;
    shared[ingKey] = state._active = state.active = state._blocked = state._force = false;
    state._step = [false, false];
    state.intentional = false;
    state._movement = [0, 0];
    state._distance = [0, 0];
    state._direction = [0, 0];
    state._delta = [0, 0];
    state._bounds = [[-Infinity, Infinity], [-Infinity, Infinity]];
    state.args = args;
    state.axis = void 0;
    state.memo = void 0;
    state.elapsedTime = state.timeDelta = 0;
    state.direction = [0, 0];
    state.distance = [0, 0];
    state.overflow = [0, 0];
    state._movementBound = [false, false];
    state.velocity = [0, 0];
    state.movement = [0, 0];
    state.delta = [0, 0];
    state.timeStamp = 0;
  }
  start(event) {
    const state = this.state;
    const config = this.config;
    if (!state._active) {
      this.reset();
      this.computeInitial();
      state._active = true;
      state.target = event.target;
      state.currentTarget = event.currentTarget;
      state.lastOffset = config.from ? call(config.from, state) : state.offset;
      state.offset = state.lastOffset;
      state.startTime = state.timeStamp = event.timeStamp;
    }
  }
  computeValues(values) {
    const state = this.state;
    state._values = values;
    state.values = this.config.transform(values);
  }
  computeInitial() {
    const state = this.state;
    state._initial = state._values;
    state.initial = state.values;
  }
  compute(event) {
    const {
      state,
      config,
      shared
    } = this;
    state.args = this.args;
    let dt = 0;
    if (event) {
      state.event = event;
      if (config.preventDefault && event.cancelable) state.event.preventDefault();
      state.type = event.type;
      shared.touches = this.ctrl.pointerIds.size || this.ctrl.touchIds.size;
      shared.locked = !!document.pointerLockElement;
      Object.assign(shared, getEventDetails(event));
      shared.down = shared.pressed = shared.buttons % 2 === 1 || shared.touches > 0;
      dt = event.timeStamp - state.timeStamp;
      state.timeStamp = event.timeStamp;
      state.elapsedTime = state.timeStamp - state.startTime;
    }
    if (state._active) {
      const _absoluteDelta = state._delta.map(Math.abs);
      V.addTo(state._distance, _absoluteDelta);
    }
    if (this.axisIntent) this.axisIntent(event);
    const [_m0, _m1] = state._movement;
    const [t0, t1] = config.threshold;
    const {
      _step,
      values
    } = state;
    if (config.hasCustomTransform) {
      if (_step[0] === false) _step[0] = Math.abs(_m0) >= t0 && values[0];
      if (_step[1] === false) _step[1] = Math.abs(_m1) >= t1 && values[1];
    } else {
      if (_step[0] === false) _step[0] = Math.abs(_m0) >= t0 && Math.sign(_m0) * t0;
      if (_step[1] === false) _step[1] = Math.abs(_m1) >= t1 && Math.sign(_m1) * t1;
    }
    state.intentional = _step[0] !== false || _step[1] !== false;
    if (!state.intentional) return;
    const movement = [0, 0];
    if (config.hasCustomTransform) {
      const [v0, v1] = values;
      movement[0] = _step[0] !== false ? v0 - _step[0] : 0;
      movement[1] = _step[1] !== false ? v1 - _step[1] : 0;
    } else {
      movement[0] = _step[0] !== false ? _m0 - _step[0] : 0;
      movement[1] = _step[1] !== false ? _m1 - _step[1] : 0;
    }
    if (this.restrictToAxis && !state._blocked) this.restrictToAxis(movement);
    const previousOffset = state.offset;
    const gestureIsActive = state._active && !state._blocked || state.active;
    if (gestureIsActive) {
      state.first = state._active && !state.active;
      state.last = !state._active && state.active;
      state.active = shared[this.ingKey] = state._active;
      if (event) {
        if (state.first) {
          if ("bounds" in config) state._bounds = call(config.bounds, state);
          if (this.setup) this.setup();
        }
        state.movement = movement;
        this.computeOffset();
      }
    }
    const [ox, oy] = state.offset;
    const [[x0, x1], [y0, y1]] = state._bounds;
    state.overflow = [ox < x0 ? -1 : ox > x1 ? 1 : 0, oy < y0 ? -1 : oy > y1 ? 1 : 0];
    state._movementBound[0] = state.overflow[0] ? state._movementBound[0] === false ? state._movement[0] : state._movementBound[0] : false;
    state._movementBound[1] = state.overflow[1] ? state._movementBound[1] === false ? state._movement[1] : state._movementBound[1] : false;
    const rubberband2 = state._active ? config.rubberband || [0, 0] : [0, 0];
    state.offset = computeRubberband(state._bounds, state.offset, rubberband2);
    state.delta = V.sub(state.offset, previousOffset);
    this.computeMovement();
    if (gestureIsActive && (!state.last || dt > BEFORE_LAST_KINEMATICS_DELAY)) {
      state.delta = V.sub(state.offset, previousOffset);
      const absoluteDelta = state.delta.map(Math.abs);
      V.addTo(state.distance, absoluteDelta);
      state.direction = state.delta.map(Math.sign);
      state._direction = state._delta.map(Math.sign);
      if (!state.first && dt > 0) {
        state.velocity = [absoluteDelta[0] / dt, absoluteDelta[1] / dt];
        state.timeDelta = dt;
      }
    }
  }
  emit() {
    const state = this.state;
    const shared = this.shared;
    const config = this.config;
    if (!state._active) this.clean();
    if ((state._blocked || !state.intentional) && !state._force && !config.triggerAllEvents) return;
    const memo = this.handler(_objectSpread2(_objectSpread2(_objectSpread2({}, shared), state), {}, {
      [this.aliasKey]: state.values
    }));
    if (memo !== void 0) state.memo = memo;
  }
  clean() {
    this.eventStore.clean();
    this.timeoutStore.clean();
  }
}
function selectAxis([dx, dy], threshold) {
  const absDx = Math.abs(dx);
  const absDy = Math.abs(dy);
  if (absDx > absDy && absDx > threshold) {
    return "x";
  }
  if (absDy > absDx && absDy > threshold) {
    return "y";
  }
  return void 0;
}
class CoordinatesEngine extends Engine {
  constructor(...args) {
    super(...args);
    _defineProperty(this, "aliasKey", "xy");
  }
  reset() {
    super.reset();
    this.state.axis = void 0;
  }
  init() {
    this.state.offset = [0, 0];
    this.state.lastOffset = [0, 0];
  }
  computeOffset() {
    this.state.offset = V.add(this.state.lastOffset, this.state.movement);
  }
  computeMovement() {
    this.state.movement = V.sub(this.state.offset, this.state.lastOffset);
  }
  axisIntent(event) {
    const state = this.state;
    const config = this.config;
    if (!state.axis && event) {
      const threshold = typeof config.axisThreshold === "object" ? config.axisThreshold[getPointerType(event)] : config.axisThreshold;
      state.axis = selectAxis(state._movement, threshold);
    }
    state._blocked = (config.lockDirection || !!config.axis) && !state.axis || !!config.axis && config.axis !== state.axis;
  }
  restrictToAxis(v) {
    if (this.config.axis || this.config.lockDirection) {
      switch (this.state.axis) {
        case "x":
          v[1] = 0;
          break;
        case "y":
          v[0] = 0;
          break;
      }
    }
  }
}
const identity = (v) => v;
const DEFAULT_RUBBERBAND = 0.15;
const commonConfigResolver = {
  enabled(value = true) {
    return value;
  },
  eventOptions(value, _k, config) {
    return _objectSpread2(_objectSpread2({}, config.shared.eventOptions), value);
  },
  preventDefault(value = false) {
    return value;
  },
  triggerAllEvents(value = false) {
    return value;
  },
  rubberband(value = 0) {
    switch (value) {
      case true:
        return [DEFAULT_RUBBERBAND, DEFAULT_RUBBERBAND];
      case false:
        return [0, 0];
      default:
        return V.toVector(value);
    }
  },
  from(value) {
    if (typeof value === "function") return value;
    if (value != null) return V.toVector(value);
  },
  transform(value, _k, config) {
    const transform = value || config.shared.transform;
    this.hasCustomTransform = !!transform;
    return transform || identity;
  },
  threshold(value) {
    return V.toVector(value, 0);
  }
};
const DEFAULT_AXIS_THRESHOLD = 0;
const coordinatesConfigResolver = _objectSpread2(_objectSpread2({}, commonConfigResolver), {}, {
  axis(_v, _k, {
    axis
  }) {
    this.lockDirection = axis === "lock";
    if (!this.lockDirection) return axis;
  },
  axisThreshold(value = DEFAULT_AXIS_THRESHOLD) {
    return value;
  },
  bounds(value = {}) {
    if (typeof value === "function") {
      return (state) => coordinatesConfigResolver.bounds(value(state));
    }
    if ("current" in value) {
      return () => value.current;
    }
    if (typeof HTMLElement === "function" && value instanceof HTMLElement) {
      return value;
    }
    const {
      left = -Infinity,
      right = Infinity,
      top = -Infinity,
      bottom = Infinity
    } = value;
    return [[left, right], [top, bottom]];
  }
});
const KEYS_DELTA_MAP = {
  ArrowRight: (displacement, factor = 1) => [displacement * factor, 0],
  ArrowLeft: (displacement, factor = 1) => [-1 * displacement * factor, 0],
  ArrowUp: (displacement, factor = 1) => [0, -1 * displacement * factor],
  ArrowDown: (displacement, factor = 1) => [0, displacement * factor]
};
class DragEngine extends CoordinatesEngine {
  constructor(...args) {
    super(...args);
    _defineProperty(this, "ingKey", "dragging");
  }
  reset() {
    super.reset();
    const state = this.state;
    state._pointerId = void 0;
    state._pointerActive = false;
    state._keyboardActive = false;
    state._preventScroll = false;
    state._delayed = false;
    state.swipe = [0, 0];
    state.tap = false;
    state.canceled = false;
    state.cancel = this.cancel.bind(this);
  }
  setup() {
    const state = this.state;
    if (state._bounds instanceof HTMLElement) {
      const boundRect = state._bounds.getBoundingClientRect();
      const targetRect = state.currentTarget.getBoundingClientRect();
      const _bounds = {
        left: boundRect.left - targetRect.left + state.offset[0],
        right: boundRect.right - targetRect.right + state.offset[0],
        top: boundRect.top - targetRect.top + state.offset[1],
        bottom: boundRect.bottom - targetRect.bottom + state.offset[1]
      };
      state._bounds = coordinatesConfigResolver.bounds(_bounds);
    }
  }
  cancel() {
    const state = this.state;
    if (state.canceled) return;
    state.canceled = true;
    state._active = false;
    setTimeout(() => {
      this.compute();
      this.emit();
    }, 0);
  }
  setActive() {
    this.state._active = this.state._pointerActive || this.state._keyboardActive;
  }
  clean() {
    this.pointerClean();
    this.state._pointerActive = false;
    this.state._keyboardActive = false;
    super.clean();
  }
  pointerDown(event) {
    const config = this.config;
    const state = this.state;
    if (event.buttons != null && (Array.isArray(config.pointerButtons) ? !config.pointerButtons.includes(event.buttons) : config.pointerButtons !== -1 && config.pointerButtons !== event.buttons)) return;
    const ctrlIds = this.ctrl.setEventIds(event);
    if (config.pointerCapture) {
      event.target.setPointerCapture(event.pointerId);
    }
    if (ctrlIds && ctrlIds.size > 1 && state._pointerActive) return;
    this.start(event);
    this.setupPointer(event);
    state._pointerId = pointerId(event);
    state._pointerActive = true;
    this.computeValues(pointerValues(event));
    this.computeInitial();
    if (config.preventScrollAxis && getPointerType(event) !== "mouse") {
      state._active = false;
      this.setupScrollPrevention(event);
    } else if (config.delay > 0) {
      this.setupDelayTrigger(event);
      if (config.triggerAllEvents) {
        this.compute(event);
        this.emit();
      }
    } else {
      this.startPointerDrag(event);
    }
  }
  startPointerDrag(event) {
    const state = this.state;
    state._active = true;
    state._preventScroll = true;
    state._delayed = false;
    this.compute(event);
    this.emit();
  }
  pointerMove(event) {
    const state = this.state;
    const config = this.config;
    if (!state._pointerActive) return;
    const id = pointerId(event);
    if (state._pointerId !== void 0 && id !== state._pointerId) return;
    const _values = pointerValues(event);
    if (document.pointerLockElement === event.target) {
      state._delta = [event.movementX, event.movementY];
    } else {
      state._delta = V.sub(_values, state._values);
      this.computeValues(_values);
    }
    V.addTo(state._movement, state._delta);
    this.compute(event);
    if (state._delayed && state.intentional) {
      this.timeoutStore.remove("dragDelay");
      state.active = false;
      this.startPointerDrag(event);
      return;
    }
    if (config.preventScrollAxis && !state._preventScroll) {
      if (state.axis) {
        if (state.axis === config.preventScrollAxis || config.preventScrollAxis === "xy") {
          state._active = false;
          this.clean();
          return;
        } else {
          this.timeoutStore.remove("startPointerDrag");
          this.startPointerDrag(event);
          return;
        }
      } else {
        return;
      }
    }
    this.emit();
  }
  pointerUp(event) {
    this.ctrl.setEventIds(event);
    try {
      if (this.config.pointerCapture && event.target.hasPointerCapture(event.pointerId)) {
        event.target.releasePointerCapture(event.pointerId);
      }
    } catch (_unused) {
    }
    const state = this.state;
    const config = this.config;
    if (!state._active || !state._pointerActive) return;
    const id = pointerId(event);
    if (state._pointerId !== void 0 && id !== state._pointerId) return;
    this.state._pointerActive = false;
    this.setActive();
    this.compute(event);
    const [dx, dy] = state._distance;
    state.tap = dx <= config.tapsThreshold && dy <= config.tapsThreshold;
    if (state.tap && config.filterTaps) {
      state._force = true;
    } else {
      const [_dx, _dy] = state._delta;
      const [_mx, _my] = state._movement;
      const [svx, svy] = config.swipe.velocity;
      const [sx, sy] = config.swipe.distance;
      const sdt = config.swipe.duration;
      if (state.elapsedTime < sdt) {
        const _vx = Math.abs(_dx / state.timeDelta);
        const _vy = Math.abs(_dy / state.timeDelta);
        if (_vx > svx && Math.abs(_mx) > sx) state.swipe[0] = Math.sign(_dx);
        if (_vy > svy && Math.abs(_my) > sy) state.swipe[1] = Math.sign(_dy);
      }
    }
    this.emit();
  }
  pointerClick(event) {
    if (!this.state.tap && event.detail > 0) {
      event.preventDefault();
      event.stopPropagation();
    }
  }
  setupPointer(event) {
    const config = this.config;
    const device = config.device;
    if (config.pointerLock) {
      event.currentTarget.requestPointerLock();
    }
    if (!config.pointerCapture) {
      this.eventStore.add(this.sharedConfig.window, device, "change", this.pointerMove.bind(this));
      this.eventStore.add(this.sharedConfig.window, device, "end", this.pointerUp.bind(this));
      this.eventStore.add(this.sharedConfig.window, device, "cancel", this.pointerUp.bind(this));
    }
  }
  pointerClean() {
    if (this.config.pointerLock && document.pointerLockElement === this.state.currentTarget) {
      document.exitPointerLock();
    }
  }
  preventScroll(event) {
    if (this.state._preventScroll && event.cancelable) {
      event.preventDefault();
    }
  }
  setupScrollPrevention(event) {
    this.state._preventScroll = false;
    persistEvent(event);
    const remove = this.eventStore.add(this.sharedConfig.window, "touch", "change", this.preventScroll.bind(this), {
      passive: false
    });
    this.eventStore.add(this.sharedConfig.window, "touch", "end", remove);
    this.eventStore.add(this.sharedConfig.window, "touch", "cancel", remove);
    this.timeoutStore.add("startPointerDrag", this.startPointerDrag.bind(this), this.config.preventScrollDelay, event);
  }
  setupDelayTrigger(event) {
    this.state._delayed = true;
    this.timeoutStore.add("dragDelay", () => {
      this.state._step = [0, 0];
      this.startPointerDrag(event);
    }, this.config.delay);
  }
  keyDown(event) {
    const deltaFn = KEYS_DELTA_MAP[event.key];
    if (deltaFn) {
      const state = this.state;
      const factor = event.shiftKey ? 10 : event.altKey ? 0.1 : 1;
      this.start(event);
      state._delta = deltaFn(this.config.keyboardDisplacement, factor);
      state._keyboardActive = true;
      V.addTo(state._movement, state._delta);
      this.compute(event);
      this.emit();
    }
  }
  keyUp(event) {
    if (!(event.key in KEYS_DELTA_MAP)) return;
    this.state._keyboardActive = false;
    this.setActive();
    this.compute(event);
    this.emit();
  }
  bind(bindFunction) {
    const device = this.config.device;
    bindFunction(device, "start", this.pointerDown.bind(this));
    if (this.config.pointerCapture) {
      bindFunction(device, "change", this.pointerMove.bind(this));
      bindFunction(device, "end", this.pointerUp.bind(this));
      bindFunction(device, "cancel", this.pointerUp.bind(this));
      bindFunction("lostPointerCapture", "", this.pointerUp.bind(this));
    }
    if (this.config.keys) {
      bindFunction("key", "down", this.keyDown.bind(this));
      bindFunction("key", "up", this.keyUp.bind(this));
    }
    if (this.config.filterTaps) {
      bindFunction("click", "", this.pointerClick.bind(this), {
        capture: true,
        passive: false
      });
    }
  }
}
function persistEvent(event) {
  "persist" in event && typeof event.persist === "function" && event.persist();
}
const isBrowser = typeof window !== "undefined" && window.document && window.document.createElement;
function supportsTouchEvents() {
  return isBrowser && "ontouchstart" in window;
}
function isTouchScreen() {
  return supportsTouchEvents() || isBrowser && window.navigator.maxTouchPoints > 1;
}
function supportsPointerEvents() {
  return isBrowser && "onpointerdown" in window;
}
function supportsPointerLock() {
  return isBrowser && "exitPointerLock" in window.document;
}
function supportsGestureEvents() {
  try {
    return "constructor" in GestureEvent;
  } catch (e) {
    return false;
  }
}
const SUPPORT = {
  isBrowser,
  gesture: supportsGestureEvents(),
  touch: supportsTouchEvents(),
  touchscreen: isTouchScreen(),
  pointer: supportsPointerEvents(),
  pointerLock: supportsPointerLock()
};
const DEFAULT_PREVENT_SCROLL_DELAY = 250;
const DEFAULT_DRAG_DELAY = 180;
const DEFAULT_SWIPE_VELOCITY = 0.5;
const DEFAULT_SWIPE_DISTANCE = 50;
const DEFAULT_SWIPE_DURATION = 250;
const DEFAULT_KEYBOARD_DISPLACEMENT = 10;
const DEFAULT_DRAG_AXIS_THRESHOLD = {
  mouse: 0,
  touch: 0,
  pen: 8
};
const dragConfigResolver = _objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
  device(_v, _k, {
    pointer: {
      touch = false,
      lock = false,
      mouse = false
    } = {}
  }) {
    this.pointerLock = lock && SUPPORT.pointerLock;
    if (SUPPORT.touch && touch) return "touch";
    if (this.pointerLock) return "mouse";
    if (SUPPORT.pointer && !mouse) return "pointer";
    if (SUPPORT.touch) return "touch";
    return "mouse";
  },
  preventScrollAxis(value, _k, {
    preventScroll
  }) {
    this.preventScrollDelay = typeof preventScroll === "number" ? preventScroll : preventScroll || preventScroll === void 0 && value ? DEFAULT_PREVENT_SCROLL_DELAY : void 0;
    if (!SUPPORT.touchscreen || preventScroll === false) return void 0;
    return value ? value : preventScroll !== void 0 ? "y" : void 0;
  },
  pointerCapture(_v, _k, {
    pointer: {
      capture = true,
      buttons = 1,
      keys = true
    } = {}
  }) {
    this.pointerButtons = buttons;
    this.keys = keys;
    return !this.pointerLock && this.device === "pointer" && capture;
  },
  threshold(value, _k, {
    filterTaps = false,
    tapsThreshold = 3,
    axis = void 0
  }) {
    const threshold = V.toVector(value, filterTaps ? tapsThreshold : axis ? 1 : 0);
    this.filterTaps = filterTaps;
    this.tapsThreshold = tapsThreshold;
    return threshold;
  },
  swipe({
    velocity = DEFAULT_SWIPE_VELOCITY,
    distance = DEFAULT_SWIPE_DISTANCE,
    duration = DEFAULT_SWIPE_DURATION
  } = {}) {
    return {
      velocity: this.transform(V.toVector(velocity)),
      distance: this.transform(V.toVector(distance)),
      duration
    };
  },
  delay(value = 0) {
    switch (value) {
      case true:
        return DEFAULT_DRAG_DELAY;
      case false:
        return 0;
      default:
        return value;
    }
  },
  axisThreshold(value) {
    if (!value) return DEFAULT_DRAG_AXIS_THRESHOLD;
    return _objectSpread2(_objectSpread2({}, DEFAULT_DRAG_AXIS_THRESHOLD), value);
  },
  keyboardDisplacement(value = DEFAULT_KEYBOARD_DISPLACEMENT) {
    return value;
  }
});
_objectSpread2(_objectSpread2({}, commonConfigResolver), {}, {
  device(_v, _k, {
    shared,
    pointer: {
      touch = false
    } = {}
  }) {
    const sharedConfig = shared;
    if (sharedConfig.target && !SUPPORT.touch && SUPPORT.gesture) return "gesture";
    if (SUPPORT.touch && touch) return "touch";
    if (SUPPORT.touchscreen) {
      if (SUPPORT.pointer) return "pointer";
      if (SUPPORT.touch) return "touch";
    }
  },
  bounds(_v, _k, {
    scaleBounds = {},
    angleBounds = {}
  }) {
    const _scaleBounds = (state) => {
      const D = assignDefault(call(scaleBounds, state), {
        min: -Infinity,
        max: Infinity
      });
      return [D.min, D.max];
    };
    const _angleBounds = (state) => {
      const A = assignDefault(call(angleBounds, state), {
        min: -Infinity,
        max: Infinity
      });
      return [A.min, A.max];
    };
    if (typeof scaleBounds !== "function" && typeof angleBounds !== "function") return [_scaleBounds(), _angleBounds()];
    return (state) => [_scaleBounds(state), _angleBounds(state)];
  },
  threshold(value, _k, config) {
    this.lockDirection = config.axis === "lock";
    const threshold = V.toVector(value, this.lockDirection ? [0.1, 3] : 0);
    return threshold;
  },
  modifierKey(value) {
    if (value === void 0) return "ctrlKey";
    return value;
  },
  pinchOnWheel(value = true) {
    return value;
  }
});
_objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
  mouseOnly: (value = true) => value
});
_objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
  mouseOnly: (value = true) => value
});
const EngineMap = /* @__PURE__ */ new Map();
const ConfigResolverMap = /* @__PURE__ */ new Map();
function registerAction(action) {
  EngineMap.set(action.key, action.engine);
  ConfigResolverMap.set(action.key, action.resolver);
}
const dragAction = {
  key: "drag",
  engine: DragEngine,
  resolver: dragConfigResolver
};
function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;
  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }
  return target;
}
function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};
  var target = _objectWithoutPropertiesLoose(source, excluded);
  var key, i;
  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }
  return target;
}
const sharedConfigResolver = {
  target(value) {
    if (value) {
      return () => "current" in value ? value.current : value;
    }
    return void 0;
  },
  enabled(value = true) {
    return value;
  },
  window(value = SUPPORT.isBrowser ? window : void 0) {
    return value;
  },
  eventOptions({
    passive = true,
    capture = false
  } = {}) {
    return {
      passive,
      capture
    };
  },
  transform(value) {
    return value;
  }
};
const _excluded = ["target", "eventOptions", "window", "enabled", "transform"];
function resolveWith(config = {}, resolvers) {
  const result = {};
  for (const [key, resolver] of Object.entries(resolvers)) {
    switch (typeof resolver) {
      case "function":
        {
          result[key] = resolver.call(result, config[key], key, config);
        }
        break;
      case "object":
        result[key] = resolveWith(config[key], resolver);
        break;
      case "boolean":
        if (resolver) result[key] = config[key];
        break;
    }
  }
  return result;
}
function parse(newConfig, gestureKey, _config = {}) {
  const _ref = newConfig, {
    target,
    eventOptions,
    window: window2,
    enabled,
    transform
  } = _ref, rest = _objectWithoutProperties(_ref, _excluded);
  _config.shared = resolveWith({
    target,
    eventOptions,
    window: window2,
    enabled,
    transform
  }, sharedConfigResolver);
  if (gestureKey) {
    const resolver = ConfigResolverMap.get(gestureKey);
    _config[gestureKey] = resolveWith(_objectSpread2({
      shared: _config.shared
    }, rest), resolver);
  } else {
    for (const key in rest) {
      const resolver = ConfigResolverMap.get(key);
      if (resolver) {
        _config[key] = resolveWith(_objectSpread2({
          shared: _config.shared
        }, rest[key]), resolver);
      }
    }
  }
  return _config;
}
class EventStore {
  constructor(ctrl, gestureKey) {
    _defineProperty(this, "_listeners", /* @__PURE__ */ new Set());
    this._ctrl = ctrl;
    this._gestureKey = gestureKey;
  }
  add(element, device, action, handler, options) {
    const listeners = this._listeners;
    const type = toDomEventType(device, action);
    const _options = this._gestureKey ? this._ctrl.config[this._gestureKey].eventOptions : {};
    const eventOptions = _objectSpread2(_objectSpread2({}, _options), options);
    element.addEventListener(type, handler, eventOptions);
    const remove = () => {
      element.removeEventListener(type, handler, eventOptions);
      listeners.delete(remove);
    };
    listeners.add(remove);
    return remove;
  }
  clean() {
    this._listeners.forEach((remove) => remove());
    this._listeners.clear();
  }
}
class TimeoutStore {
  constructor() {
    _defineProperty(this, "_timeouts", /* @__PURE__ */ new Map());
  }
  add(key, callback, ms2 = 140, ...args) {
    this.remove(key);
    this._timeouts.set(key, window.setTimeout(callback, ms2, ...args));
  }
  remove(key) {
    const timeout = this._timeouts.get(key);
    if (timeout) window.clearTimeout(timeout);
  }
  clean() {
    this._timeouts.forEach((timeout) => void window.clearTimeout(timeout));
    this._timeouts.clear();
  }
}
class Controller {
  constructor(handlers) {
    _defineProperty(this, "gestures", /* @__PURE__ */ new Set());
    _defineProperty(this, "_targetEventStore", new EventStore(this));
    _defineProperty(this, "gestureEventStores", {});
    _defineProperty(this, "gestureTimeoutStores", {});
    _defineProperty(this, "handlers", {});
    _defineProperty(this, "config", {});
    _defineProperty(this, "pointerIds", /* @__PURE__ */ new Set());
    _defineProperty(this, "touchIds", /* @__PURE__ */ new Set());
    _defineProperty(this, "state", {
      shared: {
        shiftKey: false,
        metaKey: false,
        ctrlKey: false,
        altKey: false
      }
    });
    resolveGestures(this, handlers);
  }
  setEventIds(event) {
    if (isTouch(event)) {
      this.touchIds = new Set(touchIds(event));
      return this.touchIds;
    } else if ("pointerId" in event) {
      if (event.type === "pointerup" || event.type === "pointercancel") this.pointerIds.delete(event.pointerId);
      else if (event.type === "pointerdown") this.pointerIds.add(event.pointerId);
      return this.pointerIds;
    }
  }
  applyHandlers(handlers, nativeHandlers) {
    this.handlers = handlers;
    this.nativeHandlers = nativeHandlers;
  }
  applyConfig(config, gestureKey) {
    this.config = parse(config, gestureKey, this.config);
  }
  clean() {
    this._targetEventStore.clean();
    for (const key of this.gestures) {
      this.gestureEventStores[key].clean();
      this.gestureTimeoutStores[key].clean();
    }
  }
  effect() {
    if (this.config.shared.target) this.bind();
    return () => this._targetEventStore.clean();
  }
  bind(...args) {
    const sharedConfig = this.config.shared;
    const props = {};
    let target;
    if (sharedConfig.target) {
      target = sharedConfig.target();
      if (!target) return;
    }
    if (sharedConfig.enabled) {
      for (const gestureKey of this.gestures) {
        const gestureConfig = this.config[gestureKey];
        const bindFunction = bindToProps(props, gestureConfig.eventOptions, !!target);
        if (gestureConfig.enabled) {
          const Engine2 = EngineMap.get(gestureKey);
          new Engine2(this, args, gestureKey).bind(bindFunction);
        }
      }
      const nativeBindFunction = bindToProps(props, sharedConfig.eventOptions, !!target);
      for (const eventKey in this.nativeHandlers) {
        nativeBindFunction(eventKey, "", (event) => this.nativeHandlers[eventKey](_objectSpread2(_objectSpread2({}, this.state.shared), {}, {
          event,
          args
        })), void 0, true);
      }
    }
    for (const handlerProp in props) {
      props[handlerProp] = chain(...props[handlerProp]);
    }
    if (!target) return props;
    for (const handlerProp in props) {
      const {
        device,
        capture,
        passive
      } = parseProp(handlerProp);
      this._targetEventStore.add(target, device, "", props[handlerProp], {
        capture,
        passive
      });
    }
  }
}
function setupGesture(ctrl, gestureKey) {
  ctrl.gestures.add(gestureKey);
  ctrl.gestureEventStores[gestureKey] = new EventStore(ctrl, gestureKey);
  ctrl.gestureTimeoutStores[gestureKey] = new TimeoutStore();
}
function resolveGestures(ctrl, internalHandlers) {
  if (internalHandlers.drag) setupGesture(ctrl, "drag");
  if (internalHandlers.wheel) setupGesture(ctrl, "wheel");
  if (internalHandlers.scroll) setupGesture(ctrl, "scroll");
  if (internalHandlers.move) setupGesture(ctrl, "move");
  if (internalHandlers.pinch) setupGesture(ctrl, "pinch");
  if (internalHandlers.hover) setupGesture(ctrl, "hover");
}
const bindToProps = (props, eventOptions, withPassiveOption) => (device, action, handler, options = {}, isNative = false) => {
  var _options$capture, _options$passive;
  const capture = (_options$capture = options.capture) !== null && _options$capture !== void 0 ? _options$capture : eventOptions.capture;
  const passive = (_options$passive = options.passive) !== null && _options$passive !== void 0 ? _options$passive : eventOptions.passive;
  let handlerProp = isNative ? device : toHandlerProp(device, action, capture);
  if (withPassiveOption && passive) handlerProp += "Passive";
  props[handlerProp] = props[handlerProp] || [];
  props[handlerProp].push(handler);
};
function useRecognizers(handlers, config = {}, gestureKey, nativeHandlers) {
  const ctrl = React.useMemo(() => new Controller(handlers), []);
  ctrl.applyHandlers(handlers, nativeHandlers);
  ctrl.applyConfig(config, gestureKey);
  React.useEffect(ctrl.effect.bind(ctrl));
  React.useEffect(() => {
    return ctrl.clean.bind(ctrl);
  }, []);
  if (config.target === void 0) {
    return ctrl.bind.bind(ctrl);
  }
  return void 0;
}
function useDrag(handler, config) {
  registerAction(dragAction);
  return useRecognizers({
    drag: handler
  }, config || {}, "drag");
}
function useSimpleSwipe(handler, config = {}) {
  const { stopPropagation = true, ...rest } = config;
  return useDrag(
    (state) => {
      if (stopPropagation) state.event.stopPropagation();
      if (state.swipe[0] !== 0 || state.swipe[1] !== 0) handler(state);
    },
    {
      // Nested handlers need all events to avoid propagation
      triggerAllEvents: stopPropagation,
      ...rest
    }
  );
}
const defaultProps = () => ({
  config: {
    duration: ms(String(tw.theme("transitionDuration.DEFAULT")))
  }
});
function useSimpleTransition(data, props) {
  const options = merge({}, defaultProps(), omit(props, "from", "to"), {
    from: merge({}, ...castArray(props.from)),
    enter: props.to,
    leave: props.from
  });
  return useTransition(data, options);
}
(_a = adaptivecards.AdaptiveCard).onProcessMarkdown ?? (_a.onProcessMarkdown = (text, result) => {
  result.outputHtml = `
    <div class="prose prose-sm prose-p:m-0 prose-p:overflow-hidden prose-p:text-ellipsis prose-a:text-brand-900 max-w-none [color:inherit] [font-size:inherit] [line-height:inherit]">
      ${textToHtml(text)}
    </div>
  `;
  result.didProcess = true;
});
function getHostConfig(hostConfig) {
  if (hostConfig instanceof adaptivecards.HostConfig) return hostConfig;
  return new adaptivecards.HostConfig(hostConfig ?? {});
}
function AdaptiveCard(props) {
  var _a2, _b, _c, _d, _e, _f;
  const [error, setError] = reactExports.useState();
  if (error) throw error;
  const ref = reactExports.useRef(null);
  const [refresh, setRefresh] = reactExports.useState();
  const [inViewRef, inView] = useInView();
  const isOnline = useIsOnline();
  const isFocused = useIsFocused();
  const adaptiveCard = reactExports.useRef(new adaptivecards.AdaptiveCard());
  const hostConfig = adaptiveCard.current.hostConfig = getHostConfig(props.hostConfig);
  adaptiveCard.current.onExecuteAction = (action) => {
    var _a3, _b2, _c2, _d2, _e2;
    if ("data" in action && typeof action.data === "object") action.data = { ...action.data };
    const event = new CustomEvent(action.getJsonTypeName(), {
      cancelable: true,
      detail: action
    });
    if (isExecuteAction(event.detail)) {
      (_a3 = props.onExecuteAction) == null ? void 0 : _a3.call(props, event);
    }
    if (isOpenUrlAction(event.detail)) {
      (_b2 = props.onOpenUrlAction) == null ? void 0 : _b2.call(props, event);
    }
    if (isShowCardAction(event.detail)) {
      (_c2 = props.onShowCardAction) == null ? void 0 : _c2.call(props, event);
    }
    if (isSubmitAction(event.detail)) {
      (_d2 = props.onSubmitAction) == null ? void 0 : _d2.call(props, event);
    }
    if (event.defaultPrevented) return;
    (_e2 = props.onAction) == null ? void 0 : _e2.call(props, event);
  };
  reactExports.useEffect(() => {
    if (!ref.current) return;
    try {
      adaptiveCard.current.parse(props.payload);
      const result = adaptiveCard.current.render();
      setRefresh(adaptiveCard.current.refresh);
      if (!result) throw new Error("Render returned undefined");
      ref.current.replaceChildren(result);
    } catch (error2) {
      setError(error2);
    }
  }, [props.payload, props.hostConfig]);
  reactExports.useEffect(() => {
    var _a3;
    if (!props.disabled) return;
    const nodes = (_a3 = ref.current) == null ? void 0 : _a3.querySelectorAll(".ac-selectable[tabindex]");
    if (!(nodes == null ? void 0 : nodes.length)) return;
    for (const node of nodes) {
      node.setAttribute("tabindex", "-1");
    }
    return () => {
      for (const node of nodes) {
        node.setAttribute("tabindex", "0");
      }
    };
  }, [props.disabled]);
  reactExports.useEffect(() => {
    if (!(refresh == null ? void 0 : refresh.expires) || !inView || !isOnline || !isFocused) return;
    const { expires, action } = refresh;
    const timeout = setTimeout(() => {
      if (action.isEffectivelyEnabled()) {
        action.execute();
      }
    }, expires.getTime() - Date.now());
    return () => {
      clearTimeout(timeout);
    };
  }, [refresh, inView, isOnline, isFocused]);
  return (
    // Use a fieldset so setting "disabled" will deactivate inputs
    // (It is valid for a `fieldset` to appear outside of a `form`)
    /* @__PURE__ */ jsxRuntimeExports.jsx(
      "fieldset",
      {
        ref: mergeRefs(ref, inViewRef),
        disabled: props.disabled,
        className: tx(
          "min-w-0",
          // Browsers default fieldsets to `min-width: min-content`,
          "flex flex-1 flex-col",
          { "pointer-events-none opacity-60": props.disabled },
          css`
          .ac-adaptiveCard {
            flex: 1 !important;
            padding: ${String(tw.theme("padding.3"))} !important;
            border-radius: ${String(tw.theme("borderRadius.lg"))};
          }
          .ac-horizontal-separator {
            margin-block: ${String(tw.theme("margin[0.5]"))};
          }
          .ac-selectable {
            /* [disabled] & { pointer-events: none; opacity: ${String(tw.theme("opacity.60"))}; } */
            cursor: pointer;
          }
          .ac-textBlock {
            overflow-wrap: normal !important;
          }
          .ac-textInput,
          .ac-multichoiceInput,
          .ac-dateInput,
          .ac-timeInput,
          .ac-numberInput {
            /* [disabled] & { pointer-events: none; opacity: ${String(tw.theme("opacity.60"))}; } */
            padding: ${String(tw.theme("padding.2"))};
            background-color: ${hostConfig.containerStyles.default.backgroundColor};
            border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.light.subtle};
            border-radius: ${String(tw.theme("borderRadius.DEFAULT"))};
            font-family: ${(_a2 = hostConfig.fontTypes) == null ? void 0 : _a2.default.fontFamily};
            font-size: ${(_b = hostConfig.fontTypes) == null ? void 0 : _b.default.fontSizes.default}px;
            line-height: ${(_c = hostConfig.lineHeights) == null ? void 0 : _c.default}px;
          }
          .ac-actionSet {
            flex-wrap: wrap;
            gap: 10px;
            & > div:empty {
              display: none;
            }
          }
          button.ac-pushButton,
          button.ac-pushButton-disabled {
            /* [disabled] & { pointer-events: none; opacity: ${String(tw.theme("opacity.60"))}; } */
            padding-inline: ${String(tw.theme("padding.4"))};
            padding-block: ${String(tw.theme("padding.1"))};
            border-radius: ${String(tw.theme("borderRadius.full"))};
            font-family: ${(_d = hostConfig.fontTypes) == null ? void 0 : _d.default.fontFamily};
            font-size: ${(_e = hostConfig.fontTypes) == null ? void 0 : _e.default.fontSizes.default}px;
            line-height: ${(_f = hostConfig.lineHeights) == null ? void 0 : _f.default}px;
            overflow: hidden;
            &,
            &:hover,
            &:focus,
            &:active {
              box-shadow: none;
            }
            @media (prefers-reduced-motion: no-preference) {
              transition-property: ${String(tw.theme("transitionProperty.DEFAULT"))};
              transition-timing-function: ${String(tw.theme("transitionTimingFunction.DEFAULT"))};
              transition-duration: ${String(tw.theme("transitionDuration.DEFAULT"))};
            }
            &.style-default {
              background-color: ${hostConfig.containerStyles.default.backgroundColor};
              border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.accent.subtle};
              color: ${hostConfig.containerStyles.default.foregroundColors.accent.default};
              &:hover,
              &:focus {
                background-color: ${hostConfig.containerStyles.default.foregroundColors.accent.subtle};
                border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.accent.default};
                color: ${hostConfig.containerStyles.default.backgroundColor};
              }
              &:active {
                background-color: ${hostConfig.containerStyles.emphasis.backgroundColor};
                border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.light.subtle};
                color: ${hostConfig.containerStyles.default.foregroundColors.accent.subtle};
              }
            }
            &.style-positive {
              background-color: ${hostConfig.containerStyles.default.foregroundColors.accent.default};
              border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.accent.subtle};
              color: ${hostConfig.containerStyles.default.backgroundColor};
              &:hover,
              &:focus {
                background-color: ${hostConfig.containerStyles.default.foregroundColors.accent.subtle};
                border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.accent.default};
                color: ${hostConfig.containerStyles.default.backgroundColor};
              }
              &:active {
                background-color: ${hostConfig.containerStyles.default.foregroundColors.accent.default};
                border: 1px solid ${hostConfig.containerStyles.emphasis.backgroundColor};
                color: ${hostConfig.containerStyles.default.backgroundColor};
              }
            }
            &.style-destructive {
              background-color: ${hostConfig.containerStyles.default.backgroundColor};
              border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.attention.default};
              color: ${hostConfig.containerStyles.default.foregroundColors.attention.default};
              &:hover,
              &:focus {
                background-color: ${hostConfig.containerStyles.default.foregroundColors.attention.default};
                border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.attention.subtle};
                color: ${hostConfig.containerStyles.default.backgroundColor};
              }
              &:active {
                background-color: ${hostConfig.containerStyles.default.foregroundColors.attention.subtle};
                border: 1px solid ${hostConfig.containerStyles.default.foregroundColors.attention.default};
                color: ${hostConfig.containerStyles.default.foregroundColors.attention.default};
              }
            }
          }
        `
        )
      }
    )
  );
}
const RootStateContext = reactExports.createContext(null);
function useRootState(initialState) {
  const context = reactExports.useContext(RootStateContext);
  if (context) return [void 0, context[1]];
  return reactExports.useState(initialState);
}
function RootStateProvider(props) {
  return /* @__PURE__ */ jsxRuntimeExports.jsx(RootStateContext.Provider, { value: props.state, children: props.children });
}
const loadingAnimation = keyframes`
  from {
    left: 0;
    transform: translateX(-100%);
  }
  to {
    left: 100%;
    transform: translateX(0);
  }
`;
function useIsControlled(test) {
  const logger = useWidgetsLogger();
  const [isControlled, setIsControlled] = reactExports.useState(test);
  if (test() && !isControlled) {
    logger.error("Component changed from uncontrolled to controlled.");
    setIsControlled(true);
  }
  return isControlled;
}
const getViewActionSchema = objectType({
  data: objectType({
    __internal__: objectType({
      spaceId: stringType()
    }),
    endpoint: stringType()
  }).passthrough().transform(({ __internal__: { spaceId }, endpoint, ...data }) => ({
    spaceId,
    endpoint,
    data
  }))
});
const actionNotificationActionSchema = objectType({
  data: objectType({
    __internal__: objectType({
      spaceId: stringType(),
      notificationId: stringType()
    }),
    data: objectType({}).passthrough(),
    analytics: objectType({}).passthrough().optional()
  }).passthrough().transform(({ __internal__: { spaceId, notificationId }, ...data }) => ({
    spaceId,
    notificationId,
    data
  }))
});
const deleteNotificationActionSchema = objectType({
  verb: literalType("deleteNotification"),
  data: objectType({
    __internal__: objectType({
      spaceId: stringType(),
      notificationId: stringType()
    })
  }).passthrough().transform(({ __internal__: { spaceId, notificationId } }) => ({
    spaceId,
    notificationId
  }))
});
const deleteNotificationActionedActionSchema = objectType({
  verb: literalType("deleteNotificationActioned"),
  data: objectType({
    spaceId: stringType(),
    notificationId: stringType()
  })
});
const deleteNotificationCancelledActionSchema = objectType({
  verb: literalType("deleteNotificationCancelled"),
  data: objectType({
    spaceId: stringType(),
    notificationId: stringType()
  })
});
const askFeedbackActionSchema = objectType({
  data: objectType({
    __internal__: objectType({
      spaceId: stringType()
    }),
    text: stringType(),
    id: literalType("feedback")
  }).passthrough().transform(({ __internal__: { spaceId }, text, id, ...data }) => ({
    spaceId,
    message: text,
    id,
    data
  }))
});
const askFeedbackResponseSchema = objectType({
  items: arrayType(
    objectType({
      view: adaptiveCardObjectSchema
    })
  ).length(1)
}).transform((response) => {
  return response.items[0].view;
});
function View(props) {
  const { t } = useTranslation();
  const [rootState, setRootState] = useRootState({});
  const core = useWidgetsCore();
  const logger = useWidgetsLogger();
  const queryClient = useQueryClient();
  let resolvedAction;
  let resolvedPayload;
  if ("endpoint" in props) {
    resolvedAction = {
      data: {
        __internal__: { spaceId: props.spaceId },
        endpoint: props.endpoint,
        ...props.data
      }
    };
  }
  if ("payload" in props) {
    resolvedPayload = props.payload;
  }
  if ("initialEndpoint" in props) {
    resolvedAction = {
      data: {
        __internal__: { spaceId: props.spaceId },
        endpoint: props.initialEndpoint,
        ...props.initialData
      }
    };
  }
  if ("initialPayload" in props) {
    resolvedPayload = props.initialPayload;
  }
  const isControlled = useIsControlled(() => "payload" in props || "endpoint" in props);
  const [internalAction, setInternalAction] = reactExports.useState();
  const action = internalAction ?? resolvedAction;
  const payload = reactExports.useRef(resolvedPayload);
  const viewQuery = useQuery({
    queryKey: [action ?? { payload: resolvedPayload }],
    queryFn: async () => {
      if (!action) return payload.current;
      if (getViewActionSchema.safeParse(action).success) {
        const parsedAction = getViewActionSchema.parse(action);
        return core.getView(parsedAction.data);
      }
      if (actionNotificationActionSchema.safeParse(action).success) {
        const parsedAction = actionNotificationActionSchema.parse(action);
        await core.actionNotification(parsedAction.data);
        setRootState({ submitted: true });
        return {
          type: "AdaptiveCard",
          version: "1.6"
        };
      }
      if (deleteNotificationActionSchema.safeParse(action).success) {
        const parsedAction = deleteNotificationActionSchema.parse(action);
        return {
          type: "AdaptiveCard",
          version: "1.3",
          body: [
            {
              type: "Container",
              verticalContentAlignment: "center",
              items: [
                {
                  type: "ColumnSet",
                  separator: false,
                  columns: [
                    {
                      type: "Column",
                      width: "auto",
                      items: [
                        {
                          type: "Image",
                          size: "Small",
                          style: "Person",
                          // Currently always the production endpoint
                          url: `https://cdn.workgrid.com/ask/trash-can-red.png`,
                          horizontalAlignment: "Center"
                        }
                      ]
                    },
                    {
                      type: "Column",
                      width: "stretch",
                      items: [
                        {
                          type: "ColumnSet",
                          columns: [
                            {
                              type: "Column",
                              items: [
                                {
                                  type: "TextBlock",
                                  text: t("delete-notification.subject"),
                                  verticalContentAlignment: "Center"
                                }
                              ]
                            }
                          ]
                        }
                      ]
                    }
                  ]
                }
              ]
            },
            {
              type: "TextBlock",
              text: t("delete-notification.warning"),
              wrap: true,
              weight: "bolder",
              size: "medium",
              spacing: "default",
              separator: false
            }
          ],
          actions: [
            {
              id: "delete-notification-actioned",
              type: "Action.Execute",
              verb: "deleteNotificationActioned",
              title: t("delete-notification.actions.confirm"),
              data: {
                ...parsedAction.data
              }
            },
            {
              id: "delete-notification-cancelled",
              type: "Action.Execute",
              verb: "deleteNotificationCancelled",
              title: t("delete-notification.actions.cancel"),
              data: {
                ...parsedAction.data
              }
            }
          ]
        };
      }
      if (deleteNotificationActionedActionSchema.safeParse(action).success) {
        const parsedAction = deleteNotificationActionedActionSchema.parse(action);
        const response = await core.getNotification(parsedAction.data);
        await core.deleteNotification(parsedAction.data);
        setRootState({ deleted: true });
        return response;
      }
      if (deleteNotificationCancelledActionSchema.safeParse(action).success) {
        const parsedAction = deleteNotificationCancelledActionSchema.parse(action);
        return core.getNotification(parsedAction.data);
      }
      if (askFeedbackActionSchema.safeParse(action).success) {
        const parsedAction = askFeedbackActionSchema.parse(action);
        const response = await core.ask(parsedAction.data);
        return askFeedbackResponseSchema.parse(response);
      }
      logger.error("Unexpected action", { action });
    },
    // Ensure payload is defined before rendering
    // @ts-expect-error useSuspenseQuery does not support overriding throwOnError
    suspense: true,
    // Don't bubble errors after the initial query
    throwOnError: !action,
    // Show previous payload white fetching
    // (`keepPreviousData` is cleared on error)
    placeholderData: payload.current
  });
  if (viewQuery.data) payload.current = viewQuery.data;
  const isFetching = viewQuery.isFetching;
  const isError = viewQuery.isError;
  const isSubmitted = (rootState == null ? void 0 : rootState.submitted) ?? false;
  const isDeleted = (rootState == null ? void 0 : rootState.deleted) ?? false;
  const isDisabled = isFetching || isSubmitted || isDeleted;
  const isRoot = !!rootState;
  const hostConfig = reactExports.useRef();
  hostConfig.current ?? (hostConfig.current = new adaptivecards.HostConfig(merge(getDefaultHostConfig(), props.hostConfig)));
  const [detail, setDetail] = reactExports.useState(null);
  const openTransitions = useSimpleTransition(detail, {
    from: [{ opacity: 0, scale: Number(tw.theme("scale.95")) }, { display: "none" }],
    to: [{ display: "" }, { opacity: 1, scale: Number(tw.theme("scale.100")) }]
  });
  const swipeToClose = useSimpleSwipe(
    ({ initial: [initialX], movement: [movementX] }) => {
      if (initialX < 50 && movementX > 0) setDetail(null);
    },
    { axis: "x" }
  );
  const spinDelay = distExports.useSpinDelay(isFetching, { delay: 500, minDuration: 2e3, ssr: false });
  reactExports.useEffect(() => {
    if (rootState == null ? void 0 : rootState.submitted) {
      setDetail(null);
    }
  }, [rootState == null ? void 0 : rootState.submitted]);
  if (isFetching && !isRoot) {
    return /* @__PURE__ */ jsxRuntimeExports.jsx(Loader, { label: t("loading") });
  }
  return /* @__PURE__ */ jsxRuntimeExports.jsxs(RootStateProvider, { state: [rootState, setRootState], children: [
    /* @__PURE__ */ jsxRuntimeExports.jsxs(
      "div",
      {
        ...isRoot && createAnchor(name),
        className: tx(
          "relative bg-white",
          "flex flex-1 flex-col",
          { rounded: isRoot },
          {
            [css`
              &::before {
                content: '';
                position: absolute;
                top: -3px;
                left: 0;
                transform: translateX(-100%);
                width: 4rem;
                height: 5px;
                border-radius: 100%;
                background-image: linear-gradient(
                  135deg,
                  transparent 15%,
                  ${String(tw.theme("colors.white"))} 50%,
                  transparent 85%
                );
                animation: ${loadingAnimation} 2s infinite alternate ease-in-out;
                opacity: 0.8;
              }
            `]: spinDelay
          },
          {
            [css`
              border-top: 3px solid ${hostConfig.current.containerStyles.default.foregroundColors.accent.subtle};
            `]: isRoot
          }
        ),
        children: [
          isError && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "mx-2 mt-2 bg-rose-300 bg-opacity-20 px-2 py-1 text-xs text-rose-700", children: t("request-failed") }),
          isSubmitted && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "mx-2 mt-2 bg-emerald-300 bg-opacity-20 px-2 py-1 text-xs text-emerald-700", children: t("response-submitted") }),
          isDeleted && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "mx-2 mt-2 bg-zinc-300 bg-opacity-20 px-2 py-1 text-xs text-zinc-700", children: t("delete-notification.success") }),
          /* @__PURE__ */ jsxRuntimeExports.jsx(
            AdaptiveCard,
            {
              disabled: isDisabled,
              payload: payload.current,
              hostConfig: hostConfig.current,
              onAction: (event) => {
                var _a2;
                (_a2 = props.onAction) == null ? void 0 : _a2.call(props, event);
                if (event.defaultPrevented) return;
                if (isExecuteAction(event.detail) || isSubmitAction(event.detail)) {
                  if (isControlled) return;
                  const action2 = event.detail.toJSON();
                  queryClient.removeQueries({ queryKey: [action2] });
                  setInternalAction(action2);
                }
              },
              onExecuteAction: (event) => {
                var _a2;
                (_a2 = props.onExecuteAction) == null ? void 0 : _a2.call(props, event);
                if (event.defaultPrevented) return;
              },
              onOpenUrlAction: (event) => {
                var _a2;
                (_a2 = props.onOpenUrlAction) == null ? void 0 : _a2.call(props, event);
                if (event.defaultPrevented) return;
                window.open(event.detail.url, "_blank");
              },
              onShowCardAction: (event) => {
                var _a2, _b;
                (_a2 = props.onShowCardAction) == null ? void 0 : _a2.call(props, event);
                if (event.defaultPrevented) return;
                setDetail((_b = event.detail.toJSON()) == null ? void 0 : _b.card);
              },
              onSubmitAction: (event) => {
                var _a2;
                (_a2 = props.onSubmitAction) == null ? void 0 : _a2.call(props, event);
                if (event.defaultPrevented) return;
              }
            }
          )
        ]
      }
    ),
    /* @__PURE__ */ jsxRuntimeExports.jsx(
      Root,
      {
        open: !!detail,
        onOpenChange: () => {
          setDetail(null);
        },
        modal: false,
        children: openTransitions((style, detail2) => {
          return detail2 && /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
            /* @__PURE__ */ jsxRuntimeExports.jsx(VisuallyHidden, { asChild: true, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Title, { children: t("detail") }) }),
            /* @__PURE__ */ jsxRuntimeExports.jsx(
              Content,
              {
                forceMount: true,
                onInteractOutside: (event) => {
                  event.preventDefault();
                },
                onEscapeKeyDown: (event) => {
                  event.preventDefault();
                },
                "aria-describedby": void 0,
                asChild: true,
                children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
                  animated.div,
                  {
                    ...swipeToClose(),
                    className: "absolute inset-0 z-10 flex flex-col bg-white",
                    style: { ...style, touchAction: "pan-y" },
                    "aria-hidden": !detail2,
                    children: [
                      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "flex justify-start p-2", children: /* @__PURE__ */ jsxRuntimeExports.jsx(Close, { asChild: true, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { className: "flex items-center justify-center gap-1 rounded px-2 py-1 text-zinc-600", children: [
                        /* @__PURE__ */ jsxRuntimeExports.jsx(ForwardRef, { className: "-mb-0.5 -ml-1 h-6 w-6" }),
                        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-sm font-light", children: t("close-detail") })
                      ] }) }) }),
                      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "flex flex-1 flex-col overflow-auto", children: /* @__PURE__ */ jsxRuntimeExports.jsx(
                        View,
                        {
                          spaceId: props.spaceId,
                          initialPayload: detail2,
                          hostConfig: props.hostConfig,
                          onAction: (event) => {
                            var _a2;
                            (_a2 = props.onAction) == null ? void 0 : _a2.call(props, event);
                            if (event.defaultPrevented) return;
                          },
                          onExecuteAction: (event) => {
                            var _a2;
                            (_a2 = props.onExecuteAction) == null ? void 0 : _a2.call(props, event);
                            if (event.defaultPrevented) return;
                          },
                          onOpenUrlAction: (event) => {
                            var _a2;
                            (_a2 = props.onOpenUrlAction) == null ? void 0 : _a2.call(props, event);
                            if (event.defaultPrevented) return;
                          },
                          onShowCardAction: (event) => {
                            var _a2;
                            (_a2 = props.onShowCardAction) == null ? void 0 : _a2.call(props, event);
                            if (event.defaultPrevented) return;
                          },
                          onSubmitAction: (event) => {
                            var _a2;
                            (_a2 = props.onSubmitAction) == null ? void 0 : _a2.call(props, event);
                            if (event.defaultPrevented) return;
                          }
                        }
                      ) })
                    ]
                  }
                )
              }
            )
          ] });
        })
      }
    )
  ] });
}
function getDefaultHostConfig() {
  const containerForegroundColors = {
    default: {
      default: String(tw.theme("colors.zinc.900")),
      subtle: String(tw.theme("colors.zinc.700"))
    },
    dark: {
      default: String(tw.theme("colors.zinc.900")),
      subtle: String(tw.theme("colors.zinc.700"))
    },
    light: {
      default: String(tw.theme("colors.zinc.600")),
      subtle: String(tw.theme("colors.zinc.500"))
    },
    accent: {
      default: String(tw.theme("colors.brand.900")),
      subtle: String(tw.theme("colors.brand.700"))
    },
    good: {
      default: String(tw.theme("colors.emerald.900")),
      subtle: String(tw.theme("colors.emerald.700"))
    },
    warning: {
      default: String(tw.theme("colors.amber.900")),
      subtle: String(tw.theme("colors.amber.700"))
    },
    attention: {
      default: String(tw.theme("colors.rose.900")),
      subtle: String(tw.theme("colors.rose.700"))
    }
  };
  return {
    fontTypes: {
      default: {
        fontFamily: String(tw.theme("fontFamily.sans")),
        fontSizes: {
          small: Number(toPx(String(tw.theme("fontSize.xs[0]")))),
          default: Number(toPx(String(tw.theme("fontSize.sm[0]")))),
          medium: Number(toPx(String(tw.theme("fontSize.base[0]")))),
          large: Number(toPx(String(tw.theme("fontSize.lg[0]")))),
          extraLarge: Number(toPx(String(tw.theme("fontSize.xl[0]"))))
        },
        fontWeights: {
          default: Number(tw.theme("fontWeight.normal")),
          lighter: Number(tw.theme("fontWeight.light")),
          bolder: Number(tw.theme("fontWeight.bold"))
        }
      },
      monospace: {
        fontFamily: String(tw.theme("fontFamily.mono")),
        fontSizes: {
          small: Number(toPx(String(tw.theme("fontSize.xs[0]")))),
          default: Number(toPx(String(tw.theme("fontSize.sm[0]")))),
          medium: Number(toPx(String(tw.theme("fontSize.base[0]")))),
          large: Number(toPx(String(tw.theme("fontSize.lg[0]")))),
          extraLarge: Number(toPx(String(tw.theme("fontSize.xl[0]"))))
        },
        fontWeights: {
          default: Number(tw.theme("fontWeight.normal")),
          lighter: Number(tw.theme("fontWeight.light")),
          bolder: Number(tw.theme("fontWeight.bold"))
        }
      }
    },
    lineHeights: {
      small: Number(toPx(String(tw.theme("fontSize.xs[1]")))),
      default: Number(toPx(String(tw.theme("fontSize.sm[1]")))),
      medium: Number(toPx(String(tw.theme("fontSize.base[1]")))),
      large: Number(toPx(String(tw.theme("fontSize.lg[1]")))),
      extraLarge: Number(toPx(String(tw.theme("fontSize.xl[1]"))))
    },
    containerStyles: {
      default: {
        backgroundColor: String(tw.theme("colors.white")),
        foregroundColors: containerForegroundColors
      },
      emphasis: {
        backgroundColor: String(tw.theme("colors.zinc.100")),
        foregroundColors: containerForegroundColors
      },
      accent: {
        backgroundColor: String(tw.theme("colors.brand.100")),
        foregroundColors: containerForegroundColors
      },
      good: {
        backgroundColor: String(tw.theme("colors.emerald.100")),
        foregroundColors: containerForegroundColors
      },
      warning: {
        backgroundColor: String(tw.theme("colors.amber.100")),
        foregroundColors: containerForegroundColors
      },
      attention: {
        backgroundColor: String(tw.theme("colors.rose.100")),
        foregroundColors: containerForegroundColors
      }
    },
    spacing: {
      small: Number(toPx(String(tw.theme("spacing.1")))),
      default: Number(toPx(String(tw.theme("spacing.2")))),
      padding: Number(toPx(String(tw.theme("spacing.3")))),
      medium: Number(toPx(String(tw.theme("spacing.4")))),
      large: Number(toPx(String(tw.theme("spacing.5")))),
      extraLarge: Number(toPx(String(tw.theme("spacing.6"))))
    },
    imageSizes: {
      small: Number(toPx(String(tw.theme("width.8")))),
      medium: Number(toPx(String(tw.theme("width.16")))),
      large: Number(toPx(String(tw.theme("width.32"))))
    },
    actions: {
      maxActions: 6
    }
  };
}
export {
  View as default
};
//# sourceMappingURL=view-Bm46BMwi.js.map
