@blogmcp/mdx-render-vue 0.1.0

package/dist/node_modules/@zag-js/focus-visible/dist/index.js

@@ -0,0 +1,159 @@
+import { isVirtualClick, getEventTarget } from "../../dom-query/dist/event.js";
+import { isMac } from "../../dom-query/dist/platform.js";
+import { getWindow, getDocument, getActiveElement } from "../../dom-query/dist/node.js";
+function isValidKey(e) {
+  return !(e.metaKey || !isMac() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+var nonTextInputTypes = /* @__PURE__ */ new Set(["checkbox", "radio", "range", "color", "file", "image", "button", "submit", "reset"]);
+function isKeyboardFocusEvent(isTextInput, modality, e) {
+  const eventTarget = e ? getEventTarget(e) : null;
+  const doc = getDocument(eventTarget);
+  const win = getWindow(eventTarget);
+  const activeElement = getActiveElement(doc);
+  isTextInput = isTextInput || activeElement instanceof win.HTMLInputElement && !nonTextInputTypes.has(activeElement?.type) || activeElement instanceof win.HTMLTextAreaElement || activeElement instanceof win.HTMLElement && activeElement.isContentEditable;
+  return !(isTextInput && modality === "keyboard" && e instanceof win.KeyboardEvent && !Reflect.has(FOCUS_VISIBLE_INPUT_KEYS, e.key));
+}
+var currentModality = null;
+var changeHandlers = /* @__PURE__ */ new Set();
+var listenerMap = /* @__PURE__ */ new Map();
+var hasEventBeforeFocus = false;
+var hasBlurredWindowRecently = false;
+var ignoreFocusEvent = false;
+var FOCUS_VISIBLE_INPUT_KEYS = {
+  Tab: true,
+  Escape: true
+};
+function triggerChangeHandlers(modality, e) {
+  for (let handler of changeHandlers) {
+    handler(modality, e);
+  }
+}
+function handleKeyboardEvent(e) {
+  hasEventBeforeFocus = true;
+  if (isValidKey(e)) {
+    currentModality = "keyboard";
+    triggerChangeHandlers("keyboard", e);
+  }
+}
+function handlePointerEvent(e) {
+  currentModality = "pointer";
+  if (e.type === "mousedown" || e.type === "pointerdown") {
+    hasEventBeforeFocus = true;
+    triggerChangeHandlers("pointer", e);
+  }
+}
+function handleClickEvent(e) {
+  if (isVirtualClick(e)) {
+    hasEventBeforeFocus = true;
+    currentModality = "virtual";
+  }
+}
+function handleFocusEvent(e) {
+  const target = getEventTarget(e);
+  if (target === getWindow(target) || target === getDocument(target) || ignoreFocusEvent || !e.isTrusted) {
+    return;
+  }
+  if (!hasEventBeforeFocus && !hasBlurredWindowRecently) {
+    currentModality = "virtual";
+    triggerChangeHandlers("virtual", e);
+  }
+  hasEventBeforeFocus = false;
+  hasBlurredWindowRecently = false;
+}
+function handleWindowBlur() {
+  hasEventBeforeFocus = false;
+  hasBlurredWindowRecently = true;
+}
+function setupGlobalFocusEvents(root) {
+  if (typeof window === "undefined" || listenerMap.get(getWindow(root))) {
+    return;
+  }
+  const win = getWindow(root);
+  const doc = getDocument(root);
+  let focus = win.HTMLElement.prototype.focus;
+  function patchedFocus() {
+    hasEventBeforeFocus = true;
+    focus.apply(this, arguments);
+  }
+  try {
+    Object.defineProperty(win.HTMLElement.prototype, "focus", {
+      configurable: true,
+      value: patchedFocus
+    });
+  } catch {
+  }
+  doc.addEventListener("keydown", handleKeyboardEvent, true);
+  doc.addEventListener("keyup", handleKeyboardEvent, true);
+  doc.addEventListener("click", handleClickEvent, true);
+  win.addEventListener("focus", handleFocusEvent, true);
+  win.addEventListener("blur", handleWindowBlur, false);
+  if (typeof win.PointerEvent !== "undefined") {
+    doc.addEventListener("pointerdown", handlePointerEvent, true);
+    doc.addEventListener("pointermove", handlePointerEvent, true);
+    doc.addEventListener("pointerup", handlePointerEvent, true);
+  } else {
+    doc.addEventListener("mousedown", handlePointerEvent, true);
+    doc.addEventListener("mousemove", handlePointerEvent, true);
+    doc.addEventListener("mouseup", handlePointerEvent, true);
+  }
+  win.addEventListener(
+    "beforeunload",
+    () => {
+      tearDownWindowFocusTracking(root);
+    },
+    { once: true }
+  );
+  listenerMap.set(win, { focus });
+}
+var tearDownWindowFocusTracking = (root, loadListener) => {
+  const win = getWindow(root);
+  const doc = getDocument(root);
+  const listenerData = listenerMap.get(win);
+  if (!listenerData) {
+    return;
+  }
+  try {
+    Object.defineProperty(win.HTMLElement.prototype, "focus", {
+      configurable: true,
+      value: listenerData.focus
+    });
+  } catch {
+  }
+  doc.removeEventListener("keydown", handleKeyboardEvent, true);
+  doc.removeEventListener("keyup", handleKeyboardEvent, true);
+  doc.removeEventListener("click", handleClickEvent, true);
+  win.removeEventListener("focus", handleFocusEvent, true);
+  win.removeEventListener("blur", handleWindowBlur, false);
+  if (typeof win.PointerEvent !== "undefined") {
+    doc.removeEventListener("pointerdown", handlePointerEvent, true);
+    doc.removeEventListener("pointermove", handlePointerEvent, true);
+    doc.removeEventListener("pointerup", handlePointerEvent, true);
+  } else {
+    doc.removeEventListener("mousedown", handlePointerEvent, true);
+    doc.removeEventListener("mousemove", handlePointerEvent, true);
+    doc.removeEventListener("mouseup", handlePointerEvent, true);
+  }
+  listenerMap.delete(win);
+};
+function isFocusVisible() {
+  return currentModality === "keyboard" || currentModality === "virtual";
+}
+function trackFocusVisible(props = {}) {
+  const { isTextInput, autoFocus, onChange, root } = props;
+  setupGlobalFocusEvents(root);
+  onChange?.({ isFocusVisible: autoFocus || isFocusVisible(), modality: currentModality });
+  const handler = (modality, e) => {
+    if (!isKeyboardFocusEvent(!!isTextInput, modality, e)) return;
+    onChange?.({ isFocusVisible: isFocusVisible(), modality });
+  };
+  changeHandlers.add(handler);
+  return () => {
+    changeHandlers.delete(handler);
+  };
+}
+export {
+  ignoreFocusEvent,
+  isFocusVisible,
+  listenerMap,
+  trackFocusVisible
+};

package/dist/node_modules/@zag-js/popper/dist/get-anchor.js

@@ -0,0 +1,39 @@
+import { isHTMLElement } from "../../dom-query/dist/node.js";
+function createDOMRect(x = 0, y = 0, width = 0, height = 0) {
+  if (typeof DOMRect === "function") {
+    return new DOMRect(x, y, width, height);
+  }
+  const rect = {
+    x,
+    y,
+    width,
+    height,
+    top: y,
+    right: x + width,
+    bottom: y + height,
+    left: x
+  };
+  return { ...rect, toJSON: () => rect };
+}
+function getDOMRect(anchorRect) {
+  if (!anchorRect) return createDOMRect();
+  const { x, y, width, height } = anchorRect;
+  return createDOMRect(x, y, width, height);
+}
+function getAnchorElement(anchorElement, getAnchorRect) {
+  return {
+    contextElement: isHTMLElement(anchorElement) ? anchorElement : anchorElement?.contextElement,
+    getBoundingClientRect: () => {
+      const anchor = anchorElement;
+      const anchorRect = getAnchorRect?.(anchor);
+      if (anchorRect || !anchor) {
+        return getDOMRect(anchorRect);
+      }
+      return anchor.getBoundingClientRect();
+    }
+  };
+}
+export {
+  createDOMRect,
+  getAnchorElement
+};

package/dist/node_modules/@zag-js/popper/dist/get-placement.js

@@ -0,0 +1,296 @@
+import { computePosition, autoUpdate, offset, flip, shift, arrow, size, hide, limitShift } from "../../../@floating-ui/dom/dist/floating-ui.dom.js";
+import { getAnchorElement } from "./get-anchor.js";
+import { shiftArrowMiddleware, createTransformOriginMiddleware, rectMiddleware } from "./middleware.js";
+import { getPlacementDetails } from "./placement.js";
+import { noop } from "../../utils/dist/functions.js";
+import { isNull } from "../../utils/dist/guard.js";
+import { raf } from "../../dom-query/dist/raf.js";
+import { getWindow, isHTMLElement } from "../../dom-query/dist/node.js";
+import { getComputedStyle } from "../../dom-query/dist/computed-style.js";
+import { compact } from "../../utils/dist/object.js";
+var defaultOptions = {
+  strategy: "absolute",
+  placement: "bottom",
+  listeners: true,
+  restoreStyles: false,
+  gutter: 8,
+  flip: true,
+  slide: true,
+  overlap: false,
+  sameWidth: false,
+  fitViewport: false,
+  overflowPadding: 8,
+  arrowPadding: 4
+};
+function roundByDpr(win, value) {
+  const dpr = win.devicePixelRatio || 1;
+  return Math.round(value * dpr) / dpr;
+}
+function isApproximatelyEqual(a, b) {
+  return a != null && Math.abs(a - b) < 0.5;
+}
+function resolveBoundaryOption(boundary) {
+  if (typeof boundary === "function") return boundary();
+  if (boundary === "clipping-ancestors") return "clippingAncestors";
+  return boundary;
+}
+function getArrowMiddleware(arrowElement, doc, opts) {
+  const element = arrowElement || doc.createElement("div");
+  return arrow({ element, padding: opts.arrowPadding });
+}
+function getOffsetMiddleware(arrowElement, opts) {
+  if (isNull(opts.offset ?? opts.gutter)) return;
+  return offset(({ placement }) => {
+    const arrowOffset = (arrowElement?.clientHeight || 0) / 2;
+    const gutter = opts.offset?.mainAxis ?? opts.gutter;
+    const mainAxis = typeof gutter === "number" ? gutter + arrowOffset : gutter ?? arrowOffset;
+    const { hasAlign } = getPlacementDetails(placement);
+    const shift2 = !hasAlign ? opts.shift : void 0;
+    const crossAxis = opts.offset?.crossAxis ?? shift2;
+    return compact({
+      crossAxis,
+      mainAxis,
+      alignmentAxis: opts.shift
+    });
+  });
+}
+function getFlipMiddleware(opts) {
+  if (!opts.flip) return;
+  const boundary = resolveBoundaryOption(opts.boundary);
+  return flip({
+    ...boundary ? { boundary } : void 0,
+    padding: opts.overflowPadding,
+    fallbackPlacements: opts.flip === true ? void 0 : opts.flip
+  });
+}
+function getShiftMiddleware(opts) {
+  if (!opts.slide && !opts.overlap) return;
+  const boundary = resolveBoundaryOption(opts.boundary);
+  return shift({
+    ...boundary ? { boundary } : void 0,
+    mainAxis: opts.slide,
+    crossAxis: opts.overlap,
+    padding: opts.overflowPadding,
+    limiter: limitShift()
+  });
+}
+function getSizeMiddleware(opts) {
+  if (opts.sizeMiddleware === false && !opts.sameWidth && !opts.fitViewport) return;
+  let lastReferenceWidth;
+  let lastReferenceHeight;
+  let lastAvailableWidth;
+  let lastAvailableHeight;
+  return size({
+    padding: opts.overflowPadding,
+    apply({ elements, rects, availableHeight, availableWidth }) {
+      const floating = elements.floating;
+      const referenceWidth = Math.round(rects.reference.width);
+      const referenceHeight = Math.round(rects.reference.height);
+      availableWidth = Math.floor(availableWidth);
+      availableHeight = Math.floor(availableHeight);
+      if (!isApproximatelyEqual(lastReferenceWidth, referenceWidth)) {
+        floating.style.setProperty("--reference-width", `${referenceWidth}px`);
+        lastReferenceWidth = referenceWidth;
+      }
+      if (!isApproximatelyEqual(lastReferenceHeight, referenceHeight)) {
+        floating.style.setProperty("--reference-height", `${referenceHeight}px`);
+        lastReferenceHeight = referenceHeight;
+      }
+      if (!isApproximatelyEqual(lastAvailableWidth, availableWidth)) {
+        floating.style.setProperty("--available-width", `${availableWidth}px`);
+        lastAvailableWidth = availableWidth;
+      }
+      if (!isApproximatelyEqual(lastAvailableHeight, availableHeight)) {
+        floating.style.setProperty("--available-height", `${availableHeight}px`);
+        lastAvailableHeight = availableHeight;
+      }
+    }
+  });
+}
+function hideWhenDetachedMiddleware(opts) {
+  if (!opts.hideWhenDetached) return;
+  return hide({ strategy: "referenceHidden", boundary: resolveBoundaryOption(opts.boundary) ?? "clippingAncestors" });
+}
+function getAutoUpdateOptions(opts) {
+  if (!opts) return {};
+  if (opts === true) {
+    return { ancestorResize: true, ancestorScroll: true, elementResize: true, layoutShift: true };
+  }
+  return opts;
+}
+var floatingStyleProps = [
+  "transform",
+  "visibility",
+  "pointer-events",
+  "--x",
+  "--y",
+  "--z-index",
+  "--reference-width",
+  "--reference-height",
+  "--available-width",
+  "--available-height",
+  "--transform-origin"
+];
+var arrowStyleProps = ["top", "right", "bottom", "left"];
+function createStyleCleanup(el, props) {
+  if (!el) return noop;
+  const prev = new Map(props.map((prop) => [prop, el.style.getPropertyValue(prop)]));
+  return () => {
+    prev.forEach((value, prop) => {
+      if (value) el.style.setProperty(prop, value);
+      else el.style.removeProperty(prop);
+    });
+    if (el.style.length === 0) {
+      el.removeAttribute("style");
+    }
+  };
+}
+function anchorIdentity(anchor) {
+  if (anchor == null) return null;
+  if (isHTMLElement(anchor)) return anchor;
+  if (typeof anchor === "object" && anchor && "contextElement" in anchor && anchor.contextElement) {
+    return anchor.contextElement;
+  }
+  return anchor;
+}
+function getPlacementImpl(referenceOrVirtual, floatingOrVirtual, opts = {}) {
+  const resolveFloating = () => {
+    const raw = typeof floatingOrVirtual === "function" ? floatingOrVirtual() : floatingOrVirtual;
+    return raw ?? null;
+  };
+  const resolveAnchor = () => {
+    const raw = typeof referenceOrVirtual === "function" ? referenceOrVirtual() : referenceOrVirtual;
+    return opts.getAnchorElement?.() ?? raw;
+  };
+  const resolveReference = () => {
+    const anchor = resolveAnchor();
+    if (!anchor && !opts.getAnchorRect) return null;
+    return getAnchorElement(anchor, opts.getAnchorRect);
+  };
+  const options = Object.assign({}, defaultOptions, opts);
+  let middleware = [];
+  let cachedMiddlewareFloating = null;
+  let restoreFloatingStyles;
+  let restoreArrowStyles;
+  function rebuildMiddlewareForFloating(floating) {
+    restoreFloatingStyles?.();
+    restoreArrowStyles?.();
+    cachedMiddlewareFloating = floating;
+    restoreFloatingStyles = options.restoreStyles ? createStyleCleanup(floating, floatingStyleProps) : void 0;
+    const arrowEl = floating.querySelector("[data-part=arrow]");
+    restoreArrowStyles = options.restoreStyles ? createStyleCleanup(arrowEl, arrowStyleProps) : void 0;
+    middleware = [
+      getOffsetMiddleware(arrowEl, options),
+      getFlipMiddleware(options),
+      getShiftMiddleware(options),
+      getArrowMiddleware(arrowEl, floating.ownerDocument, options),
+      shiftArrowMiddleware(arrowEl),
+      createTransformOriginMiddleware(
+        { gutter: options.gutter, offset: options.offset, overlap: options.overlap },
+        arrowEl
+      ),
+      getSizeMiddleware(options),
+      hideWhenDetachedMiddleware(options),
+      rectMiddleware
+    ];
+  }
+  const { placement, strategy, onComplete, onPositioned } = options;
+  let lastX;
+  let lastY;
+  let zIndexComputed = false;
+  let lastAnchorForObserve = void 0;
+  let lastFloatingForObserve = void 0;
+  let cancelAutoUpdate = noop;
+  const autoUpdateOptions = getAutoUpdateOptions(options.listeners);
+  function syncAutoUpdateObservers() {
+    if (!options.listeners) return;
+    const anchor = resolveAnchor();
+    const reference = resolveReference();
+    const floating = resolveFloating();
+    if (!reference || !floating) return;
+    const anchorChanged = anchorIdentity(anchor) !== anchorIdentity(lastAnchorForObserve);
+    const floatingChanged = floating !== lastFloatingForObserve;
+    if (anchorChanged || floatingChanged) {
+      cancelAutoUpdate();
+      lastAnchorForObserve = anchor;
+      lastFloatingForObserve = floating;
+      cancelAutoUpdate = autoUpdate(reference, floating, runUpdate, autoUpdateOptions);
+    }
+  }
+  async function updatePosition() {
+    syncAutoUpdateObservers();
+    const floating = resolveFloating();
+    if (!floating) return;
+    if (floating !== cachedMiddlewareFloating) {
+      rebuildMiddlewareForFloating(floating);
+      zIndexComputed = false;
+    }
+    const reference = resolveReference();
+    if (!reference) return;
+    const pos = await computePosition(reference, floating, {
+      placement,
+      middleware,
+      strategy
+    });
+    onComplete?.(pos);
+    const win = getWindow(floating);
+    const x = roundByDpr(win, pos.x);
+    const y = roundByDpr(win, pos.y);
+    if (!isApproximatelyEqual(lastX, x)) {
+      floating.style.setProperty("--x", `${x}px`);
+      lastX = x;
+    }
+    if (!isApproximatelyEqual(lastY, y)) {
+      floating.style.setProperty("--y", `${y}px`);
+      lastY = y;
+    }
+    if (options.hideWhenDetached) {
+      const isHidden = pos.middlewareData.hide?.referenceHidden;
+      if (isHidden) {
+        floating.style.setProperty("visibility", "hidden");
+        floating.style.setProperty("pointer-events", "none");
+      } else {
+        floating.style.removeProperty("visibility");
+        floating.style.removeProperty("pointer-events");
+      }
+    }
+    if (!zIndexComputed) {
+      const contentEl = floating.firstElementChild;
+      if (contentEl) {
+        floating.style.setProperty("--z-index", getComputedStyle(contentEl).zIndex);
+        zIndexComputed = true;
+      }
+    }
+  }
+  async function runUpdate() {
+    if (opts.updatePosition) {
+      await opts.updatePosition({ updatePosition, floatingElement: resolveFloating() });
+      onPositioned?.({ placed: true });
+    } else {
+      await updatePosition();
+    }
+  }
+  runUpdate();
+  return () => {
+    cancelAutoUpdate();
+    restoreArrowStyles?.();
+    restoreFloatingStyles?.();
+    onPositioned?.({ placed: false });
+  };
+}
+function getPlacement(referenceOrFn, floatingOrFn, opts = {}) {
+  const { defer, ...options } = opts;
+  const func = defer ? raf : (v) => v();
+  const cleanups = [];
+  cleanups.push(
+    func(() => {
+      cleanups.push(getPlacementImpl(referenceOrFn, floatingOrFn, options));
+    })
+  );
+  return () => {
+    cleanups.forEach((fn) => fn?.());
+  };
+}
+export {
+  getPlacement
+};

package/dist/node_modules/@zag-js/popper/dist/get-styles.js

@@ -0,0 +1,47 @@
+import { cssVars } from "./middleware.js";
+var ARROW_FLOATING_STYLE = {
+  bottom: "rotate(45deg)",
+  left: "rotate(135deg)",
+  top: "rotate(225deg)",
+  right: "rotate(315deg)"
+};
+function getPlacementStyles(options = {}) {
+  const { placement, sameWidth, fitViewport, strategy = "absolute" } = options;
+  return {
+    arrow: {
+      position: "absolute",
+      width: cssVars.arrowSize.reference,
+      height: cssVars.arrowSize.reference,
+      [cssVars.arrowSizeHalf.variable]: `calc(${cssVars.arrowSize.reference} / 2)`,
+      [cssVars.arrowOffset.variable]: `calc(${cssVars.arrowSizeHalf.reference} * -1)`
+    },
+    arrowTip: {
+      // @ts-expect-error - Fix this
+      transform: placement ? ARROW_FLOATING_STYLE[placement.split("-")[0]] : void 0,
+      background: cssVars.arrowBg.reference,
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      position: "absolute",
+      zIndex: "inherit"
+    },
+    floating: {
+      position: strategy,
+      isolation: "isolate",
+      minWidth: sameWidth ? void 0 : "max-content",
+      width: sameWidth ? "var(--reference-width)" : void 0,
+      maxWidth: fitViewport ? "var(--available-width)" : void 0,
+      maxHeight: fitViewport ? "var(--available-height)" : void 0,
+      pointerEvents: !placement ? "none" : void 0,
+      top: "0px",
+      left: "0px",
+      // move off-screen if placement is not defined
+      transform: placement ? "translate3d(var(--x), var(--y), 0)" : "translate3d(0, -100vh, 0)",
+      zIndex: "var(--z-index)"
+    }
+  };
+}
+export {
+  getPlacementStyles
+};

package/dist/node_modules/@zag-js/popper/dist/middleware.js

@@ -0,0 +1,79 @@
+var toVar = (value) => ({ variable: value, reference: `var(${value})` });
+var cssVars = {
+  arrowSize: toVar("--arrow-size"),
+  arrowSizeHalf: toVar("--arrow-size-half"),
+  arrowBg: toVar("--arrow-background"),
+  transformOrigin: toVar("--transform-origin"),
+  arrowOffset: toVar("--arrow-offset")
+};
+var getSideAxis = (side) => side === "top" || side === "bottom" ? "y" : "x";
+function createTransformOriginMiddleware(opts, arrowEl) {
+  return {
+    name: "transformOrigin",
+    fn(state) {
+      const { elements, middlewareData, placement, rects, y } = state;
+      const side = placement.split("-")[0];
+      const axis = getSideAxis(side);
+      const arrowX = middlewareData.arrow?.x || 0;
+      const arrowY = middlewareData.arrow?.y || 0;
+      const arrowWidth = arrowEl?.clientWidth || 0;
+      const arrowHeight = arrowEl?.clientHeight || 0;
+      const transformX = arrowX + arrowWidth / 2;
+      const transformY = arrowY + arrowHeight / 2;
+      const shiftY = Math.abs(middlewareData.shift?.y || 0);
+      const halfAnchorHeight = rects.reference.height / 2;
+      const arrowOffset = arrowHeight / 2;
+      const gutter = opts.offset?.mainAxis ?? opts.gutter;
+      const sideOffsetValue = typeof gutter === "number" ? gutter + arrowOffset : gutter ?? arrowOffset;
+      const isOverlappingAnchor = shiftY > sideOffsetValue;
+      const adjacentTransformOrigin = {
+        top: `${transformX}px calc(100% + ${sideOffsetValue}px)`,
+        bottom: `${transformX}px ${-sideOffsetValue}px`,
+        left: `calc(100% + ${sideOffsetValue}px) ${transformY}px`,
+        right: `${-sideOffsetValue}px ${transformY}px`
+      }[side];
+      const overlapTransformOrigin = `${transformX}px ${rects.reference.y + halfAnchorHeight - y}px`;
+      const useOverlap = Boolean(opts.overlap) && axis === "y" && isOverlappingAnchor;
+      elements.floating.style.setProperty(
+        cssVars.transformOrigin.variable,
+        useOverlap ? overlapTransformOrigin : adjacentTransformOrigin
+      );
+      return {
+        data: {
+          transformOrigin: useOverlap ? overlapTransformOrigin : adjacentTransformOrigin
+        }
+      };
+    }
+  };
+}
+var rectMiddleware = {
+  name: "rects",
+  fn({ rects }) {
+    return {
+      data: rects
+    };
+  }
+};
+var shiftArrowMiddleware = (arrowEl) => {
+  if (!arrowEl) return;
+  return {
+    name: "shiftArrow",
+    fn({ placement, middlewareData }) {
+      if (!middlewareData.arrow) return {};
+      const { x, y } = middlewareData.arrow;
+      const dir = placement.split("-")[0];
+      Object.assign(arrowEl.style, {
+        left: x != null ? `${x}px` : "",
+        top: y != null ? `${y}px` : "",
+        [dir]: `calc(100% + ${cssVars.arrowOffset.reference})`
+      });
+      return {};
+    }
+  };
+};
+export {
+  createTransformOriginMiddleware,
+  cssVars,
+  rectMiddleware,
+  shiftArrowMiddleware
+};

package/dist/node_modules/@zag-js/popper/dist/placement.js

@@ -0,0 +1,7 @@
+function getPlacementDetails(placement) {
+  const [side, align] = placement.split("-");
+  return { side, align, hasAlign: align != null };
+}
+export {
+  getPlacementDetails
+};

package/dist/node_modules/@zag-js/presence/dist/presence.connect.js

@@ -0,0 +1,18 @@
+function connect(service, _normalize) {
+  const { state, send, context } = service;
+  const present = state.matches("mounted", "unmountSuspended");
+  return {
+    skip: !context.get("initial"),
+    present,
+    setNode(node) {
+      if (!node) return;
+      send({ type: "NODE.SET", node });
+    },
+    unmount() {
+      send({ type: "UNMOUNT" });
+    }
+  };
+}
+export {
+  connect
+};