@powerduck/schema-designer 0.1.0

package/dist/chunk-GXXD6ITE.cjs

@@ -0,0 +1,1477 @@
+'use strict';
+
+var chunkOOSNM45O_cjs = require('./chunk-OOSNM45O.cjs');
+var react = require('react');
+var react$1 = require('@chakra-ui/react');
+var autocomplete = require('@codemirror/autocomplete');
+var commands = require('@codemirror/commands');
+var state = require('@codemirror/state');
+var view = require('@codemirror/view');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react/variableTextEditor/VariableTextEditor.module.css
+var VariableTextEditor_default = {
+  root: "VariableTextEditor_root",
+  variableToken: "VariableTextEditor_variableToken",
+  variableToken_unknown: "VariableTextEditor_variableToken_unknown",
+  variableToken_environment: "VariableTextEditor_variableToken_environment",
+  variableToken_secret: "VariableTextEditor_variableToken_secret",
+  variableToken_request: "VariableTextEditor_variableToken_request",
+  variableToken_dynamic: "VariableTextEditor_variableToken_dynamic",
+  hoverPopover: "VariableTextEditor_hoverPopover",
+  hoverPopoverArrow: "VariableTextEditor_hoverPopoverArrow",
+  popoverHeader: "VariableTextEditor_popoverHeader",
+  popoverType: "VariableTextEditor_popoverType",
+  popoverValue: "VariableTextEditor_popoverValue",
+  popoverDesc: "VariableTextEditor_popoverDesc"
+};
+var EMPTY_VARIABLES = Object.freeze([]);
+var TOKEN_SELECTOR = `.${VariableTextEditor_default.variableToken}`;
+var HOVER_OPEN_DELAY = 260;
+var HOVER_CLOSE_DELAY = 50;
+var POPOVER_GAP = 14;
+var VIEWPORT_MARGIN = 12;
+var POPOVER_MAX_WIDTH = 360;
+var POPOVER_FALLBACK_HEIGHT = 200;
+var MAX_PENDING_CONTROLLED_VALUES = 16;
+var ExternalValueUpdate = state.Annotation.define();
+var VariablesSnapshotUpdate = state.Annotation.define();
+function variablesEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    const left = a[i];
+    const right = b[i];
+    if (left.name !== right.name || left.value !== right.value || left.description !== right.description || left.type !== right.type || left.color !== right.color || left.backgroundColor !== right.backgroundColor) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeRanges(ranges) {
+  if (ranges.length <= 1) return ranges.slice();
+  const sorted = ranges.filter((range) => range.to > range.from).slice().sort((a, b) => {
+    if (a.from !== b.from) return a.from - b.from;
+    return a.to - b.to;
+  });
+  if (sorted.length <= 1) return sorted;
+  const result = [];
+  let current = {
+    from: sorted[0].from,
+    to: sorted[0].to
+  };
+  for (let i = 1; i < sorted.length; i += 1) {
+    const next = sorted[i];
+    if (next.from <= current.to) {
+      current.to = Math.max(current.to, next.to);
+      continue;
+    }
+    result.push(current);
+    current = {
+      from: next.from,
+      to: next.to
+    };
+  }
+  result.push(current);
+  return result;
+}
+function createInputInvariantFilter(maxLengthRef, allowLineBreaksRef, isComposingRef) {
+  return state.EditorState.transactionFilter.of((transaction) => {
+    if (!transaction.docChanged) {
+      return transaction;
+    }
+    if (isComposingRef.current) {
+      return transaction;
+    }
+    const newDoc = transaction.newDoc;
+    const invalidRanges = [];
+    if (!allowLineBreaksRef.current) {
+      const text = newDoc.toString();
+      const newlineRegex = /[\r\n\u2028\u2029]+/g;
+      let match;
+      while ((match = newlineRegex.exec(text)) !== null) {
+        const from = match.index;
+        const to = from + match[0].length;
+        invalidRanges.push({ from, to });
+      }
+    }
+    const limit = maxLengthRef.current;
+    if (Number.isFinite(limit) && newDoc.length > limit) {
+      invalidRanges.push({
+        from: Math.max(0, Math.floor(limit)),
+        to: newDoc.length
+      });
+    }
+    if (invalidRanges.length === 0) {
+      return transaction;
+    }
+    const merged = mergeRanges(invalidRanges);
+    return [
+      transaction,
+      {
+        changes: merged.map(({ from, to }) => ({
+          from,
+          to,
+          insert: ""
+        })),
+        sequential: true
+      }
+    ];
+  });
+}
+var VariableDecorationPlugin = class {
+  constructor(view, getSnapshot, tokenIndexRef, classes) {
+    this.getSnapshot = getSnapshot;
+    this.tokenIndexRef = tokenIndexRef;
+    this.classes = classes;
+    this.rebuild(view.state);
+  }
+  getSnapshot;
+  tokenIndexRef;
+  classes;
+  decorations = view.Decoration.none;
+  rebuild(state) {
+    const snapshot = this.getSnapshot();
+    const doc = state.doc.toString();
+    const tokens = chunkOOSNM45O_cjs.findVariableTokens(doc, snapshot.variables);
+    this.tokenIndexRef.current = {
+      doc,
+      variablesVersion: snapshot.version,
+      tokens
+    };
+    this.decorations = chunkOOSNM45O_cjs.createTokenDecorations(
+      state,
+      snapshot.variables,
+      this.classes,
+      tokens
+    );
+  }
+  update(update) {
+    if (update.docChanged || update.transactions.some(
+      (transaction) => transaction.annotation(VariablesSnapshotUpdate) !== void 0
+    ))
+      this.rebuild(update.state);
+  }
+};
+function createVariableDecorationExtension(snapshotRef, tokenIndexRef) {
+  const getSnapshot = () => snapshotRef.current;
+  const plugin = view.ViewPlugin.fromClass(
+    class extends VariableDecorationPlugin {
+      constructor(view) {
+        super(view, getSnapshot, tokenIndexRef, VariableTextEditor_default);
+      }
+    },
+    {
+      decorations: (plugin2) => plugin2.decorations
+    }
+  );
+  return plugin;
+}
+function createVariableCompletionExtension(variables) {
+  return autocomplete.autocompletion({
+    override: [chunkOOSNM45O_cjs.createVariableCompletionSource(variables)],
+    activateOnTyping: true,
+    defaultKeymap: false
+  });
+}
+var VariableTextEditor = react.memo(
+  (props) => {
+    const {
+      value,
+      variables: variablesProp,
+      disabled = false,
+      readOnly = false,
+      placeholder = "",
+      ariaLabel = "Variable text editor",
+      className,
+      autoFocus = false,
+      submitOnEnter = false,
+      minHeight = 32,
+      expansionMode = "inline",
+      safePadding = 8,
+      maxFocusedHeight = 320,
+      maxLength,
+      allowLineBreaks = false,
+      onChange,
+      onSubmit,
+      onFocus,
+      onBlur
+    } = props;
+    const variables = variablesProp ?? EMPTY_VARIABLES;
+    const safeMaxLength = chunkOOSNM45O_cjs.normalizeMaximumLength(maxLength);
+    const normalizedValue = chunkOOSNM45O_cjs.sanitizePlainText(
+      value,
+      safeMaxLength,
+      allowLineBreaks
+    );
+    const safeMinHeight = Number.isFinite(minHeight) ? Math.max(32, Math.round(minHeight)) : 32;
+    const safeMaxHeight = Number.isFinite(maxFocusedHeight) ? Math.max(safeMinHeight, Math.round(maxFocusedHeight)) : Math.max(safeMinHeight, 320);
+    const hostRef = react.useRef(null);
+    const tooltipRef = react.useRef(null);
+    const viewRef = react.useRef(null);
+    const destroyedRef = react.useRef(false);
+    const isComposingRef = react.useRef(false);
+    const pendingCompositionSyncRef = react.useRef(false);
+    const initialValueRef = react.useRef(normalizedValue);
+    const editorValueRef = react.useRef(normalizedValue);
+    const lastAcknowledgedPropValueRef = react.useRef(normalizedValue);
+    const pendingEmittedValuesRef = react.useRef([]);
+    const [hover, setHover] = react.useState(null);
+    const hoverRef = react.useRef(null);
+    const [focused, setFocused] = react.useState(false);
+    const focusedRef = react.useRef(false);
+    const [focusedHeight, setFocusedHeight] = react.useState(safeMinHeight);
+    const focusedHeightRef = react.useRef(safeMinHeight);
+    const [wrapped, setWrapped] = react.useState(false);
+    const wrappedRef = react.useRef(false);
+    const anchorRef = react.useRef(null);
+    const [overlayStyle, setOverlayStyle] = react.useState();
+    react.useLayoutEffect(() => {
+      if (!focused || expansionMode !== "overlay") {
+        setOverlayStyle(void 0);
+        return;
+      }
+      let frame = 0;
+      const position = () => {
+        frame = 0;
+        const anchor = anchorRef.current;
+        if (!anchor) return;
+        const rect = anchor.getBoundingClientRect();
+        if (rect.bottom <= 0 || rect.top >= window.innerHeight) {
+          viewRef.current?.contentDOM.blur();
+          return;
+        }
+        const height = Math.min(focusedHeight, window.innerHeight - 16);
+        const top = Math.max(
+          8,
+          Math.min(rect.top, window.innerHeight - height - 8)
+        );
+        setOverlayStyle({
+          position: "fixed",
+          top,
+          left: Math.max(8, rect.left),
+          width: Math.min(
+            rect.width,
+            window.innerWidth - Math.max(8, rect.left) - 8
+          ),
+          maxHeight: Math.max(safeMinHeight, window.innerHeight - top - 8),
+          zIndex: 1100
+        });
+      };
+      const schedule = () => {
+        if (!frame) frame = requestAnimationFrame(position);
+      };
+      position();
+      window.addEventListener("scroll", schedule, true);
+      window.addEventListener("resize", schedule);
+      const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(schedule);
+      if (anchorRef.current) observer?.observe(anchorRef.current);
+      return () => {
+        cancelAnimationFrame(frame);
+        observer?.disconnect();
+        window.removeEventListener("scroll", schedule, true);
+        window.removeEventListener("resize", schedule);
+      };
+    }, [focused, expansionMode, focusedHeight, safeMinHeight]);
+    const [popoverPosition, setPopoverPosition] = react.useState(null);
+    const activeTokenKeyRef = react.useRef(null);
+    const lastPointerTokenKeyRef = react.useRef(null);
+    const openTimerRef = react.useRef(null);
+    const closeTimerRef = react.useRef(null);
+    const frameRef = react.useRef(null);
+    const pointerRafRef = react.useRef(null);
+    const repositionRafRef = react.useRef(null);
+    const resizeObserverRef = react.useRef(null);
+    const tooltipResizeObserverRef = react.useRef(null);
+    const pointerInEditorRef = react.useRef(false);
+    const pointerInPopoverRef = react.useRef(false);
+    const markPopoverPointerDownUntilRef = react.useRef(0);
+    const variablesSnapshotRef = react.useRef({
+      variables,
+      version: 1
+    });
+    const disabledRef = react.useRef(disabled);
+    const readOnlyRef = react.useRef(readOnly);
+    const submitOnEnterRef = react.useRef(submitOnEnter);
+    const allowLineBreaksRef = react.useRef(allowLineBreaks);
+    const maxLengthRef = react.useRef(safeMaxLength);
+    const onChangeRef = react.useRef(onChange);
+    const onSubmitRef = react.useRef(onSubmit);
+    const onFocusRef = react.useRef(onFocus);
+    const onBlurRef = react.useRef(onBlur);
+    const editableCompartmentRef = react.useRef(new state.Compartment());
+    const variableDecorationCompartmentRef = react.useRef(new state.Compartment());
+    const variableCompletionCompartmentRef = react.useRef(new state.Compartment());
+    const placeholderCompartmentRef = react.useRef(new state.Compartment());
+    const ariaCompartmentRef = react.useRef(new state.Compartment());
+    const wrappingCompartmentRef = react.useRef(new state.Compartment());
+    const tokenIndexRef = react.useRef({
+      doc: normalizedValue,
+      variablesVersion: variablesSnapshotRef.current.version,
+      tokens: []
+    });
+    const pendingPointerRef = react.useRef(null);
+    const rootStyle = react.useMemo(
+      () => ({
+        "--editor-min-height": `${safeMinHeight}px`,
+        "--editor-max-focused-height": `${safeMaxHeight}px`,
+        "--editor-padding-block": `${Number.isFinite(safePadding) ? Math.max(0, safePadding) : 8}px`,
+        "--editor-focused-height": `${focusedHeight}px`
+      }),
+      [focusedHeight, safeMaxHeight, safeMinHeight, safePadding]
+    );
+    const sameRect = react.useCallback(
+      (a, b, eps = 0.01) => {
+        return Math.abs(a.left - b.left) < eps && Math.abs(a.top - b.top) < eps && Math.abs(a.width - b.width) < eps && Math.abs(a.height - b.height) < eps;
+      },
+      []
+    );
+    react.useEffect(() => {
+      focusedHeightRef.current = focusedHeight;
+    }, [focusedHeight]);
+    react.useEffect(() => {
+      wrappedRef.current = wrapped;
+    }, [wrapped]);
+    const cancelOpen = react.useCallback(() => {
+      if (openTimerRef.current !== null) {
+        window.clearTimeout(openTimerRef.current);
+        openTimerRef.current = null;
+      }
+    }, []);
+    const cancelClose = react.useCallback(() => {
+      if (closeTimerRef.current !== null) {
+        window.clearTimeout(closeTimerRef.current);
+        closeTimerRef.current = null;
+      }
+    }, []);
+    const cancelFrame = react.useCallback(() => {
+      if (frameRef.current !== null) {
+        window.cancelAnimationFrame(frameRef.current);
+        frameRef.current = null;
+      }
+    }, []);
+    const cancelRepositionFrame = react.useCallback(() => {
+      if (repositionRafRef.current !== null) {
+        window.cancelAnimationFrame(repositionRafRef.current);
+        repositionRafRef.current = null;
+      }
+    }, []);
+    const commitHover = react.useCallback(
+      (next) => {
+        if (destroyedRef.current) {
+          return;
+        }
+        const current = hoverRef.current;
+        if (!current && !next) {
+          return;
+        }
+        if (current && next && current.tokenKey === next.tokenKey && sameRect(current.rect, next.rect)) {
+          return;
+        }
+        hoverRef.current = next;
+        activeTokenKeyRef.current = next?.tokenKey ?? null;
+        setHover(next);
+        if (!next) {
+          setPopoverPosition(null);
+        }
+      },
+      [sameRect]
+    );
+    const closeHover = react.useCallback(() => {
+      cancelOpen();
+      cancelClose();
+      cancelRepositionFrame();
+      commitHover(null);
+    }, [cancelClose, cancelOpen, cancelRepositionFrame, commitHover]);
+    const markPopoverPointerDown = react.useCallback(() => {
+      markPopoverPointerDownUntilRef.current = Date.now() + 150;
+    }, []);
+    const requestFinalClose = react.useCallback(() => {
+      cancelClose();
+      closeTimerRef.current = window.setTimeout(() => {
+        closeTimerRef.current = null;
+        if (destroyedRef.current) {
+          return;
+        }
+        if (Date.now() < markPopoverPointerDownUntilRef.current) {
+          return;
+        }
+        const shouldClose = !pointerInEditorRef.current && !pointerInPopoverRef.current && !focusedRef.current;
+        if (!shouldClose) {
+          return;
+        }
+        closeHover();
+        setWrapped(false);
+        setFocusedHeight(safeMinHeight);
+      }, HOVER_CLOSE_DELAY);
+    }, [cancelClose, closeHover, safeMinHeight]);
+    const scheduleClose = react.useCallback(() => {
+      cancelClose();
+      closeTimerRef.current = window.setTimeout(() => {
+        closeTimerRef.current = null;
+        if (destroyedRef.current) {
+          return;
+        }
+        if (Date.now() < markPopoverPointerDownUntilRef.current) {
+          return;
+        }
+        if (tooltipRef.current?.matches(":hover, :focus-within")) {
+          return;
+        }
+        commitHover(null);
+      }, HOVER_CLOSE_DELAY);
+    }, [cancelClose, commitHover]);
+    const getTokensCurrent = react.useCallback(
+      (view) => {
+        const doc = view.state.doc.toString();
+        const snapshot = variablesSnapshotRef.current;
+        const cached = tokenIndexRef.current;
+        if (cached.doc === doc && cached.variablesVersion === snapshot.version) {
+          return cached.tokens;
+        }
+        const tokens = chunkOOSNM45O_cjs.findVariableTokens(doc, snapshot.variables);
+        tokenIndexRef.current = {
+          doc,
+          variablesVersion: snapshot.version,
+          tokens
+        };
+        return tokens;
+      },
+      []
+    );
+    const getTokenAtPointer = react.useCallback(
+      (snapshot) => {
+        const view = viewRef.current;
+        if (destroyedRef.current || !view) {
+          return null;
+        }
+        const tokens = getTokensCurrent(view);
+        if (!tokens.length) {
+          return null;
+        }
+        const pos = view.posAtCoords({
+          x: snapshot.clientX,
+          y: snapshot.clientY
+        });
+        if (pos == null) {
+          return null;
+        }
+        return chunkOOSNM45O_cjs.tokenAtPosition(tokens, pos) ?? null;
+      },
+      [getTokensCurrent]
+    );
+    const fullLineTokenRectFromView = react.useCallback(
+      (view, from, to) => {
+        if (view.state.doc.length === 0) return null;
+        const host = view.dom;
+        const selector = `${TOKEN_SELECTOR}[data-variable-from="${chunkOOSNM45O_cjs.escapeCssAttrValue(String(from))}"][data-variable-to="${chunkOOSNM45O_cjs.escapeCssAttrValue(String(to))}"]`;
+        const element = host.querySelector(selector);
+        if (element) {
+          const tokenRect = element.getBoundingClientRect();
+          const lineElement = element.closest(".cm-line");
+          const lineRect = lineElement?.getBoundingClientRect();
+          const editorRect = view.dom.getBoundingClientRect();
+          const top2 = Math.max(editorRect.top, lineRect?.top ?? tokenRect.top);
+          const bottom2 = Math.min(
+            editorRect.bottom,
+            lineRect?.bottom ?? tokenRect.bottom
+          );
+          const height2 = Math.max(tokenRect.height, bottom2 - top2);
+          const width2 = tokenRect.width;
+          if (width2 <= 0 || height2 <= 0) {
+            return null;
+          }
+          return new DOMRect(tokenRect.left, top2, width2, height2);
+        }
+        const startCoords = view.coordsAtPos(from);
+        const endCoords = view.coordsAtPos(to);
+        if (!startCoords || !endCoords) {
+          return null;
+        }
+        const left = startCoords.left;
+        const right = endCoords.right;
+        const top = Math.min(startCoords.top, endCoords.top);
+        const bottom = Math.max(startCoords.bottom, endCoords.bottom);
+        const width = right - left;
+        const height = bottom - top;
+        if (width <= 0 || height <= 0) {
+          return null;
+        }
+        return new DOMRect(left, top, width, height);
+      },
+      []
+    );
+    const buildHoverFromToken = react.useCallback(
+      (view, token) => {
+        if (destroyedRef.current) {
+          return null;
+        }
+        const rect = fullLineTokenRectFromView(view, token.from, token.to);
+        if (!rect || rect.width <= 0 || rect.height <= 0) {
+          return null;
+        }
+        const tokenKey = `${token.from}:${token.to}:${token.name}`;
+        return {
+          tokenKey,
+          rect,
+          from: token.from,
+          to: token.to,
+          name: token.name,
+          variable: token.variable
+        };
+      },
+      [fullLineTokenRectFromView]
+    );
+    const showToken = react.useCallback(
+      (token) => {
+        if (destroyedRef.current) {
+          return;
+        }
+        const view = viewRef.current;
+        if (!view || disabledRef.current) {
+          return;
+        }
+        const nextHover = buildHoverFromToken(view, token);
+        if (!nextHover) {
+          closeHover();
+          return;
+        }
+        if (activeTokenKeyRef.current === nextHover.tokenKey && hoverRef.current && hoverRef.current.tokenKey === nextHover.tokenKey && sameRect(hoverRef.current.rect, nextHover.rect)) {
+          return;
+        }
+        commitHover(nextHover);
+      },
+      [buildHoverFromToken, closeHover, commitHover, sameRect]
+    );
+    const scheduleOpen = react.useCallback(
+      (snapshot, token) => {
+        cancelClose();
+        cancelOpen();
+        openTimerRef.current = window.setTimeout(() => {
+          openTimerRef.current = null;
+          if (destroyedRef.current) {
+            return;
+          }
+          const view = viewRef.current;
+          if (!view || disabledRef.current) {
+            return;
+          }
+          const tokens = getTokensCurrent(view);
+          const latest = tokens.find(
+            (candidate) => candidate.from === token.from && candidate.to === token.to && candidate.token === token.token
+          );
+          if (!latest) {
+            return;
+          }
+          const latestToken = getTokenAtPointer(snapshot);
+          if (!latestToken || latestToken.from !== latest.from || latestToken.to !== latest.to) {
+            return;
+          }
+          showToken(latest);
+        }, HOVER_OPEN_DELAY);
+      },
+      [cancelClose, cancelOpen, getTokenAtPointer, getTokensCurrent, showToken]
+    );
+    const flushPointer = react.useCallback(() => {
+      pointerRafRef.current = null;
+      const snapshot = pendingPointerRef.current;
+      pendingPointerRef.current = null;
+      if (!snapshot || destroyedRef.current) {
+        return;
+      }
+      pointerInEditorRef.current = true;
+      const token = getTokenAtPointer(snapshot);
+      if (token) {
+        const tokenKey = `${token.from}:${token.to}:${token.name}`;
+        if (lastPointerTokenKeyRef.current !== tokenKey) {
+          lastPointerTokenKeyRef.current = tokenKey;
+          scheduleOpen(snapshot, token);
+        } else if (!hoverRef.current) {
+          scheduleOpen(snapshot, token);
+        }
+        return;
+      }
+      lastPointerTokenKeyRef.current = null;
+      if (hoverRef.current) {
+        requestFinalClose();
+      } else {
+        cancelOpen();
+      }
+    }, [cancelOpen, getTokenAtPointer, requestFinalClose, scheduleOpen]);
+    const schedulePointerFlush = react.useCallback(
+      (event) => {
+        pendingPointerRef.current = {
+          clientX: event.clientX,
+          clientY: event.clientY
+        };
+        if (pointerRafRef.current !== null) {
+          return;
+        }
+        pointerRafRef.current = window.requestAnimationFrame(flushPointer);
+      },
+      [flushPointer]
+    );
+    const handlePointerMove = react.useCallback(
+      (event) => {
+        schedulePointerFlush(event);
+      },
+      [schedulePointerFlush]
+    );
+    const handleHostPointerEnter = react.useCallback(() => {
+      pointerInEditorRef.current = true;
+    }, []);
+    const handleHostPointerLeave = react.useCallback(() => {
+      pointerInEditorRef.current = false;
+      cancelOpen();
+      requestFinalClose();
+    }, [cancelOpen, requestFinalClose]);
+    const handleTooltipPointerEnter = react.useCallback(() => {
+      pointerInPopoverRef.current = true;
+      cancelClose();
+    }, [cancelClose]);
+    const handleTooltipPointerLeave = react.useCallback(() => {
+      pointerInPopoverRef.current = false;
+      requestFinalClose();
+    }, [requestFinalClose]);
+    const measureFocusedHeight = react.useCallback(() => {
+      if (destroyedRef.current || !focusedRef.current) {
+        return;
+      }
+      const expectedView = viewRef.current;
+      if (!expectedView) {
+        return;
+      }
+      if (frameRef.current !== null) {
+        return;
+      }
+      frameRef.current = window.requestAnimationFrame(() => {
+        frameRef.current = null;
+        if (destroyedRef.current) {
+          return;
+        }
+        if (viewRef.current !== expectedView) {
+          return;
+        }
+        if (!focusedRef.current) {
+          return;
+        }
+        const content = expectedView.contentDOM;
+        const measuredRaw = Math.max(
+          safeMinHeight,
+          Math.ceil(content.scrollHeight)
+        );
+        const stableHeight = measuredRaw <= safeMinHeight + 2 ? safeMinHeight : measuredRaw;
+        const nextHeight = Math.min(stableHeight, safeMaxHeight);
+        const nextWrapped = stableHeight > safeMinHeight;
+        const currentHeight = focusedHeightRef.current;
+        const currentWrapped = wrappedRef.current;
+        if (nextHeight === currentHeight && nextWrapped === currentWrapped) {
+          return;
+        }
+        focusedHeightRef.current = nextHeight;
+        wrappedRef.current = nextWrapped;
+        setFocusedHeight(nextHeight);
+        setWrapped(nextWrapped);
+      });
+    }, [safeMaxHeight, safeMinHeight]);
+    const calculatePopoverPosition = react.useCallback(
+      (rect, width, height) => {
+        const safeWidth = Math.min(
+          POPOVER_MAX_WIDTH,
+          Math.max(1, window.innerWidth - VIEWPORT_MARGIN * 2)
+        );
+        const actualWidth = Math.min(
+          safeWidth,
+          Math.max(1, width || safeWidth)
+        );
+        const actualHeight = Math.max(1, height || POPOVER_FALLBACK_HEIGHT);
+        const tokenCenter = rect.left + rect.width / 2;
+        const left = Math.max(
+          VIEWPORT_MARGIN,
+          Math.min(
+            tokenCenter - actualWidth / 2,
+            window.innerWidth - actualWidth - VIEWPORT_MARGIN
+          )
+        );
+        const canPlaceBelow = rect.bottom + POPOVER_GAP + actualHeight <= window.innerHeight - VIEWPORT_MARGIN;
+        const canPlaceAbove = rect.top - POPOVER_GAP - actualHeight >= VIEWPORT_MARGIN;
+        const showAbove = !canPlaceBelow && canPlaceAbove;
+        const top = showAbove ? Math.max(VIEWPORT_MARGIN, rect.top - actualHeight - POPOVER_GAP) : Math.min(
+          Math.max(VIEWPORT_MARGIN, rect.bottom + POPOVER_GAP),
+          Math.max(
+            VIEWPORT_MARGIN,
+            window.innerHeight - actualHeight - VIEWPORT_MARGIN
+          )
+        );
+        return {
+          left,
+          top,
+          placement: showAbove ? "top" : "bottom",
+          arrowLeft: Math.max(
+            12,
+            Math.min(tokenCenter - left, actualWidth - 12)
+          )
+        };
+      },
+      []
+    );
+    const repositionPopover = react.useCallback(() => {
+      if (destroyedRef.current) {
+        return;
+      }
+      const currentHover = hoverRef.current;
+      if (!currentHover) {
+        return;
+      }
+      const tooltip = tooltipRef.current;
+      const rect = currentHover.rect;
+      const tooltipRect = tooltip?.getBoundingClientRect();
+      const width = tooltipRect?.width || Math.min(POPOVER_MAX_WIDTH, window.innerWidth - VIEWPORT_MARGIN * 2);
+      const height = tooltipRect?.height || POPOVER_FALLBACK_HEIGHT;
+      const next = calculatePopoverPosition(rect, width, height);
+      setPopoverPosition((previous) => {
+        if (previous && previous.left === next.left && previous.top === next.top && previous.placement === next.placement && previous.arrowLeft === next.arrowLeft) {
+          return previous;
+        }
+        return next;
+      });
+    }, [calculatePopoverPosition]);
+    const schedulePopoverReposition = react.useCallback(() => {
+      if (repositionRafRef.current !== null) {
+        return;
+      }
+      repositionRafRef.current = window.requestAnimationFrame(() => {
+        repositionRafRef.current = null;
+        repositionPopover();
+      });
+    }, [repositionPopover]);
+    const applyExternalValue = react.useCallback(
+      (view, nextValue) => {
+        if (destroyedRef.current || viewRef.current !== view) {
+          return false;
+        }
+        const currentDoc = view.state.doc.toString();
+        if (currentDoc === nextValue) {
+          editorValueRef.current = currentDoc;
+          return false;
+        }
+        closeHover();
+        view.dispatch({
+          changes: {
+            from: 0,
+            to: currentDoc.length,
+            insert: nextValue
+          },
+          annotations: ExternalValueUpdate.of(true)
+        });
+        editorValueRef.current = nextValue;
+        return true;
+      },
+      [closeHover]
+    );
+    react.useLayoutEffect(() => {
+      disabledRef.current = disabled;
+      readOnlyRef.current = readOnly;
+      submitOnEnterRef.current = submitOnEnter;
+      allowLineBreaksRef.current = allowLineBreaks;
+      maxLengthRef.current = safeMaxLength;
+      onChangeRef.current = onChange;
+      onSubmitRef.current = onSubmit;
+      onFocusRef.current = onFocus;
+      onBlurRef.current = onBlur;
+    }, [
+      disabled,
+      readOnly,
+      submitOnEnter,
+      allowLineBreaks,
+      safeMaxLength,
+      onChange,
+      onSubmit,
+      onFocus,
+      onBlur
+    ]);
+    const measurementRef = react.useRef(measureFocusedHeight);
+    const minimumHeightRef = react.useRef(safeMinHeight);
+    react.useLayoutEffect(() => {
+      measurementRef.current = measureFocusedHeight;
+      minimumHeightRef.current = safeMinHeight;
+      measureFocusedHeight();
+    }, [measureFocusedHeight, safeMinHeight]);
+    react.useLayoutEffect(() => {
+      const host = hostRef.current;
+      if (!host || viewRef.current) {
+        return;
+      }
+      destroyedRef.current = false;
+      const editable = !disabledRef.current && !readOnlyRef.current;
+      const view$1 = new view.EditorView({
+        parent: host,
+        state: state.EditorState.create({
+          doc: initialValueRef.current,
+          extensions: [
+            commands.history(),
+            view.drawSelection({
+              cursorBlinkRate: 1200
+            }),
+            state.EditorState.allowMultipleSelections.of(false),
+            editableCompartmentRef.current.of([
+              state.EditorState.readOnly.of(!editable),
+              view.EditorView.editable.of(editable)
+            ]),
+            /**
+             * P0:
+             *
+             * All document invariants are enforced at the transaction level.
+             */
+            createInputInvariantFilter(
+              maxLengthRef,
+              allowLineBreaksRef,
+              isComposingRef
+            ),
+            wrappingCompartmentRef.current.of([]),
+            view.EditorView.updateListener.of((update) => {
+              if (update.docChanged) {
+                closeHover();
+                const newLength = update.state.doc.length;
+                if (newLength === 0) {
+                  hoverRef.current = null;
+                  activeTokenKeyRef.current = null;
+                  lastPointerTokenKeyRef.current = null;
+                  setHover(null);
+                  setPopoverPosition(null);
+                  cancelRepositionFrame();
+                }
+              }
+              if (!update.docChanged) {
+                return;
+              }
+              const isExternal = update.transactions.some(
+                (transaction) => transaction.annotation(ExternalValueUpdate) === true
+              );
+              const rawValue = update.state.doc.toString();
+              editorValueRef.current = rawValue;
+              if (isComposingRef.current) {
+                pendingCompositionSyncRef.current = true;
+                return;
+              }
+              if (isExternal) {
+                return;
+              }
+              const nextValue = chunkOOSNM45O_cjs.sanitizePlainText(
+                rawValue,
+                maxLengthRef.current,
+                allowLineBreaksRef.current
+              );
+              if (nextValue !== rawValue) {
+                return;
+              }
+              if (focusedRef.current) {
+                measurementRef.current();
+              }
+              pendingEmittedValuesRef.current.push(nextValue);
+              if (pendingEmittedValuesRef.current.length > MAX_PENDING_CONTROLLED_VALUES) {
+                pendingEmittedValuesRef.current = pendingEmittedValuesRef.current.slice(
+                  -MAX_PENDING_CONTROLLED_VALUES
+                );
+              }
+              onChangeRef.current?.(nextValue);
+            }),
+            variableDecorationCompartmentRef.current.of(
+              createVariableDecorationExtension(
+                variablesSnapshotRef,
+                tokenIndexRef
+              )
+            ),
+            variableCompletionCompartmentRef.current.of(
+              createVariableCompletionExtension(
+                variablesSnapshotRef.current.variables
+              )
+            ),
+            placeholderCompartmentRef.current.of(
+              placeholder ? view.placeholder(placeholder) : []
+            ),
+            ariaCompartmentRef.current.of(
+              view.EditorView.contentAttributes.of({
+                "aria-label": ariaLabel,
+                "aria-disabled": disabledRef.current ? "true" : "false",
+                "aria-readonly": readOnlyRef.current ? "true" : "false",
+                spellcheck: "false",
+                autocapitalize: "off",
+                autocomplete: "off"
+              })
+            ),
+            view.keymap.of([
+              ...autocomplete.completionKeymap,
+              ...commands.historyKeymap,
+              ...commands.defaultKeymap
+            ]),
+            view.EditorView.domEventHandlers({
+              compositionstart() {
+                isComposingRef.current = true;
+                return false;
+              },
+              compositionend() {
+                isComposingRef.current = false;
+                queueMicrotask(() => {
+                  if (destroyedRef.current || viewRef.current !== view$1) {
+                    return;
+                  }
+                  if (!pendingCompositionSyncRef.current) {
+                    return;
+                  }
+                  pendingCompositionSyncRef.current = false;
+                  const rawValue = view$1.state.doc.toString();
+                  const normalized = chunkOOSNM45O_cjs.sanitizePlainText(
+                    rawValue,
+                    maxLengthRef.current,
+                    allowLineBreaksRef.current
+                  );
+                  if (normalized !== rawValue) {
+                    view$1.dispatch({
+                      changes: {
+                        from: 0,
+                        to: rawValue.length,
+                        insert: normalized
+                      },
+                      annotations: ExternalValueUpdate.of(true)
+                    });
+                    editorValueRef.current = normalized;
+                    pendingEmittedValuesRef.current.push(normalized);
+                    onChangeRef.current?.(normalized);
+                    return;
+                  }
+                  editorValueRef.current = rawValue;
+                  pendingEmittedValuesRef.current.push(rawValue);
+                  onChangeRef.current?.(rawValue);
+                });
+                return false;
+              },
+              keydown(event, currentView) {
+                if (event.isComposing || isComposingRef.current || disabledRef.current || readOnlyRef.current)
+                  return false;
+                if (event.key !== "Enter") {
+                  return false;
+                }
+                if (allowLineBreaksRef.current) {
+                  return false;
+                }
+                if (autocomplete.acceptCompletion(currentView)) {
+                  event.preventDefault();
+                  event.stopPropagation();
+                  return true;
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                if (submitOnEnterRef.current) {
+                  onSubmitRef.current?.(currentView.state.doc.toString());
+                }
+                return true;
+              },
+              beforeinput(event, currentView) {
+                if (disabledRef.current || readOnlyRef.current) {
+                  event.preventDefault();
+                  return true;
+                }
+                if (isComposingRef.current) {
+                  return false;
+                }
+                if (!event.inputType.startsWith("insert")) {
+                  return false;
+                }
+                const text = event.data;
+                if (!allowLineBreaksRef.current) {
+                  if (event.inputType === "insertLineBreak" || event.inputType === "insertParagraph" || event.inputType === "insertNewline") {
+                    event.preventDefault();
+                    return true;
+                  }
+                  if (text != null && /[\r\n\u2028\u2029]/.test(text)) {
+                    event.preventDefault();
+                    return true;
+                  }
+                }
+                if (!text) {
+                  return false;
+                }
+                const normalizedInsert = allowLineBreaksRef.current ? text : text.replace(/[\r\n\u2028\u2029]+/g, " ");
+                const selection = currentView.state.selection.main;
+                const insert = chunkOOSNM45O_cjs.truncateInsertion(
+                  normalizedInsert,
+                  currentView.state.doc.length,
+                  selection.to - selection.from,
+                  maxLengthRef.current
+                );
+                if (insert === text) {
+                  return false;
+                }
+                event.preventDefault();
+                if (insert) {
+                  currentView.dispatch(
+                    currentView.state.replaceSelection(insert)
+                  );
+                }
+                return true;
+              },
+              paste(event, currentView) {
+                if (disabledRef.current || readOnlyRef.current) {
+                  event.preventDefault();
+                  return true;
+                }
+                const text = event.clipboardData?.getData("text/plain");
+                if (text === void 0) {
+                  return false;
+                }
+                event.preventDefault();
+                const normalizedInsert = allowLineBreaksRef.current ? text : text.replace(/[\r\n\u2028\u2029]+/g, " ");
+                const selection = currentView.state.selection.main;
+                const insert = chunkOOSNM45O_cjs.truncateInsertion(
+                  normalizedInsert,
+                  currentView.state.doc.length,
+                  selection.to - selection.from,
+                  maxLengthRef.current
+                );
+                if (insert) {
+                  currentView.dispatch(
+                    currentView.state.replaceSelection(insert)
+                  );
+                }
+                return true;
+              },
+              drop(event, currentView) {
+                if (disabledRef.current || readOnlyRef.current) {
+                  event.preventDefault();
+                  return true;
+                }
+                const text = event.dataTransfer?.getData("text/plain");
+                if (text === void 0) {
+                  return false;
+                }
+                event.preventDefault();
+                const normalizedInsert = allowLineBreaksRef.current ? text : text.replace(/[\r\n\u2028\u2029]+/g, " ");
+                const position = currentView.posAtCoords({
+                  x: event.clientX,
+                  y: event.clientY
+                });
+                const selection = currentView.state.selection.main;
+                const hasSelection = !selection.empty && position != null;
+                let from;
+                let to;
+                let replacedLength;
+                if (hasSelection) {
+                  from = selection.from;
+                  to = selection.to;
+                  replacedLength = to - from;
+                } else {
+                  from = position ?? selection.from;
+                  to = from;
+                  replacedLength = 0;
+                }
+                const insert = chunkOOSNM45O_cjs.truncateInsertion(
+                  normalizedInsert,
+                  currentView.state.doc.length,
+                  replacedLength,
+                  maxLengthRef.current
+                );
+                if (insert) {
+                  currentView.dispatch({
+                    changes: {
+                      from,
+                      to,
+                      insert
+                    },
+                    selection: {
+                      anchor: from + insert.length
+                    },
+                    scrollIntoView: true,
+                    userEvent: "input.drop"
+                  });
+                }
+                return true;
+              },
+              focus() {
+                if (destroyedRef.current || viewRef.current !== view$1) {
+                  return false;
+                }
+                focusedRef.current = true;
+                setFocused(true);
+                view$1.dispatch({
+                  effects: wrappingCompartmentRef.current.reconfigure([
+                    view.EditorView.lineWrapping
+                  ])
+                });
+                queueMicrotask(() => {
+                  if (destroyedRef.current || viewRef.current !== view$1) {
+                    return;
+                  }
+                  if (!view$1.hasFocus) {
+                    return;
+                  }
+                  measurementRef.current();
+                });
+                onFocusRef.current?.();
+                return false;
+              },
+              blur() {
+                if (destroyedRef.current || viewRef.current !== view$1) {
+                  return false;
+                }
+                focusedRef.current = false;
+                setFocused(false);
+                setWrapped(false);
+                focusedHeightRef.current = minimumHeightRef.current;
+                setFocusedHeight(minimumHeightRef.current);
+                scheduleClose();
+                view$1.dispatch({
+                  effects: wrappingCompartmentRef.current.reconfigure([])
+                });
+                onBlurRef.current?.();
+                return false;
+              }
+            })
+          ]
+        })
+      });
+      viewRef.current = view$1;
+      editorValueRef.current = view$1.state.doc.toString();
+      if (typeof ResizeObserver !== "undefined") {
+        resizeObserverRef.current = new ResizeObserver(() => {
+          if (destroyedRef.current) {
+            return;
+          }
+          const currentView = viewRef.current;
+          if (!currentView || currentView !== view$1) {
+            return;
+          }
+          if (focusedRef.current) {
+            measurementRef.current();
+          }
+        });
+        resizeObserverRef.current.observe(host);
+      }
+      if (autoFocus && editable) {
+        queueMicrotask(() => {
+          if (destroyedRef.current || viewRef.current !== view$1) {
+            return;
+          }
+          if (!view$1.hasFocus) {
+            view$1.focus();
+          }
+        });
+      }
+      return () => {
+        destroyedRef.current = true;
+        focusedRef.current = false;
+        isComposingRef.current = false;
+        pendingCompositionSyncRef.current = false;
+        cancelOpen();
+        cancelClose();
+        cancelFrame();
+        cancelRepositionFrame();
+        resizeObserverRef.current?.disconnect();
+        resizeObserverRef.current = null;
+        tooltipResizeObserverRef.current?.disconnect();
+        tooltipResizeObserverRef.current = null;
+        if (pointerRafRef.current !== null) {
+          window.cancelAnimationFrame(pointerRafRef.current);
+          pointerRafRef.current = null;
+        }
+        pendingPointerRef.current = null;
+        hoverRef.current = null;
+        activeTokenKeyRef.current = null;
+        lastPointerTokenKeyRef.current = null;
+        tokenIndexRef.current = {
+          doc: "",
+          variablesVersion: variablesSnapshotRef.current.version,
+          tokens: []
+        };
+        setHover(null);
+        setPopoverPosition(null);
+        if (viewRef.current === view$1) {
+          viewRef.current = null;
+        }
+        try {
+          view$1.destroy();
+        } catch {
+        }
+      };
+    }, []);
+    react.useEffect(() => {
+      const view = viewRef.current;
+      if (!view || destroyedRef.current) {
+        return;
+      }
+      if (isComposingRef.current) {
+        return;
+      }
+      const nextValue = normalizedValue;
+      const currentDoc = view.state.doc.toString();
+      if (currentDoc === nextValue) {
+        editorValueRef.current = currentDoc;
+        lastAcknowledgedPropValueRef.current = nextValue;
+        pendingEmittedValuesRef.current = [];
+        return;
+      }
+      if (nextValue === lastAcknowledgedPropValueRef.current) {
+        return;
+      }
+      const pendingIndex = pendingEmittedValuesRef.current.indexOf(nextValue);
+      if (pendingIndex !== -1) {
+        lastAcknowledgedPropValueRef.current = nextValue;
+        pendingEmittedValuesRef.current = pendingEmittedValuesRef.current.slice(
+          pendingIndex + 1
+        );
+        return;
+      }
+      pendingEmittedValuesRef.current = [];
+      lastAcknowledgedPropValueRef.current = nextValue;
+      applyExternalValue(view, nextValue);
+    }, [applyExternalValue, normalizedValue]);
+    react.useEffect(() => {
+      const view$1 = viewRef.current;
+      if (!view$1 || destroyedRef.current) {
+        return;
+      }
+      const editableNow = !disabled && !readOnly;
+      if (!editableNow) {
+        closeHover();
+        if (view$1.hasFocus) {
+          try {
+            view$1.contentDOM.blur();
+          } catch {
+          }
+        }
+        focusedRef.current = false;
+        setFocused(false);
+        setWrapped(false);
+        focusedHeightRef.current = safeMinHeight;
+        setFocusedHeight(safeMinHeight);
+        view$1.dispatch({
+          effects: wrappingCompartmentRef.current.reconfigure([])
+        });
+      }
+      view$1.dispatch({
+        effects: [
+          editableCompartmentRef.current.reconfigure([
+            state.EditorState.readOnly.of(!editableNow),
+            view.EditorView.editable.of(editableNow)
+          ]),
+          ariaCompartmentRef.current.reconfigure(
+            view.EditorView.contentAttributes.of({
+              "aria-label": ariaLabel,
+              "aria-disabled": disabled ? "true" : "false",
+              "aria-readonly": readOnly ? "true" : "false",
+              spellcheck: "false",
+              autocapitalize: "off",
+              autocomplete: "off"
+            })
+          )
+        ]
+      });
+    }, [ariaLabel, closeHover, disabled, readOnly, safeMinHeight]);
+    react.useEffect(() => {
+      const view = viewRef.current;
+      if (!view || destroyedRef.current) {
+        return;
+      }
+      const currentSnapshot = variablesSnapshotRef.current;
+      if (variablesEqual(currentSnapshot.variables, variables)) {
+        return;
+      }
+      closeHover();
+      activeTokenKeyRef.current = null;
+      lastPointerTokenKeyRef.current = null;
+      const nextVersion = currentSnapshot.version + 1;
+      variablesSnapshotRef.current = {
+        variables,
+        version: nextVersion
+      };
+      tokenIndexRef.current = {
+        doc: view.state.doc.toString(),
+        variablesVersion: nextVersion,
+        tokens: []
+      };
+      view.dispatch({
+        annotations: VariablesSnapshotUpdate.of(nextVersion)
+      });
+      view.dispatch({
+        effects: variableCompletionCompartmentRef.current.reconfigure(
+          createVariableCompletionExtension(variables)
+        )
+      });
+    }, [closeHover, variables]);
+    react.useEffect(() => {
+      const view$1 = viewRef.current;
+      if (!view$1 || destroyedRef.current) {
+        return;
+      }
+      view$1.dispatch({
+        effects: placeholderCompartmentRef.current.reconfigure(
+          placeholder ? view.placeholder(placeholder) : []
+        )
+      });
+    }, [placeholder]);
+    react.useLayoutEffect(() => {
+      if (!hover) {
+        tooltipResizeObserverRef.current?.disconnect();
+        tooltipResizeObserverRef.current = null;
+        setPopoverPosition(null);
+        return;
+      }
+      setPopoverPosition(null);
+      repositionPopover();
+      if (typeof ResizeObserver !== "undefined" && tooltipRef.current) {
+        tooltipResizeObserverRef.current?.disconnect();
+        const observer = new ResizeObserver(() => {
+          schedulePopoverReposition();
+        });
+        observer.observe(tooltipRef.current);
+        tooltipResizeObserverRef.current = observer;
+      }
+      return () => {
+        tooltipResizeObserverRef.current?.disconnect();
+        tooltipResizeObserverRef.current = null;
+      };
+    }, [hover?.tokenKey, repositionPopover, schedulePopoverReposition]);
+    react.useEffect(() => {
+      if (!hover?.tokenKey) {
+        return;
+      }
+      const reposition = () => {
+        if (destroyedRef.current || repositionRafRef.current !== null) {
+          return;
+        }
+        const view = viewRef.current;
+        const latestHover = hoverRef.current;
+        if (!view || !latestHover || view.state.doc.length === 0) {
+          closeHover();
+          return;
+        }
+        repositionRafRef.current = window.requestAnimationFrame(() => {
+          repositionRafRef.current = null;
+          if (destroyedRef.current) {
+            return;
+          }
+          const view2 = viewRef.current;
+          const latestHover2 = hoverRef.current;
+          if (!view2 || !latestHover2) {
+            closeHover();
+            return;
+          }
+          const tokens = getTokensCurrent(view2);
+          const latest = tokens.find(
+            (token) => `${token.from}:${token.to}:${token.name}` === latestHover2.tokenKey
+          );
+          if (!latest) {
+            closeHover();
+            return;
+          }
+          const rect = fullLineTokenRectFromView(view2, latest.from, latest.to);
+          if (!rect) {
+            closeHover();
+            return;
+          }
+          if (!sameRect(latestHover2.rect, rect)) {
+            commitHover({
+              tokenKey: latestHover2.tokenKey,
+              rect,
+              from: latest.from,
+              to: latest.to,
+              name: latest.name,
+              variable: latest.variable
+            });
+          }
+          repositionPopover();
+        });
+      };
+      window.addEventListener("resize", reposition, { passive: true });
+      window.addEventListener("scroll", reposition, {
+        passive: true,
+        capture: true
+      });
+      return () => {
+        window.removeEventListener("resize", reposition);
+        window.removeEventListener("scroll", reposition, true);
+        cancelRepositionFrame();
+      };
+    }, [
+      cancelRepositionFrame,
+      closeHover,
+      commitHover,
+      fullLineTokenRectFromView,
+      getTokensCurrent,
+      hover?.tokenKey,
+      repositionPopover,
+      sameRect
+    ]);
+    const popoverStyle = react.useMemo(() => {
+      if (!popoverPosition) {
+        return {
+          position: "fixed",
+          zIndex: 999999,
+          pointerEvents: "auto",
+          left: 0,
+          top: 0,
+          visibility: "hidden"
+        };
+      }
+      return {
+        position: "fixed",
+        zIndex: 999999,
+        pointerEvents: "auto",
+        left: popoverPosition.left,
+        top: popoverPosition.top,
+        visibility: "visible",
+        "--popover-arrow-left": `${popoverPosition.arrowLeft}px`
+      };
+    }, [popoverPosition]);
+    const popoverNode = hover ? /* @__PURE__ */ jsxRuntime.jsxs(
+      react$1.Box,
+      {
+        ref: tooltipRef,
+        className: VariableTextEditor_default.hoverPopover,
+        style: popoverStyle,
+        "data-placement": popoverPosition?.placement ?? "bottom",
+        onPointerEnter: handleTooltipPointerEnter,
+        onPointerLeave: handleTooltipPointerLeave,
+        onPointerDown: markPopoverPointerDown,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(react$1.Box, { className: VariableTextEditor_default.hoverPopoverArrow }),
+          /* @__PURE__ */ jsxRuntime.jsx(react$1.Box, { className: VariableTextEditor_default.popoverHeader, children: hover.variable?.name ?? hover.name }),
+          /* @__PURE__ */ jsxRuntime.jsx(react$1.Box, { className: VariableTextEditor_default.popoverType, children: hover.variable?.type ?? "Undefined variable" }),
+          hover.variable?.value !== void 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: VariableTextEditor_default.popoverValue, children: hover.variable.value }) : null,
+          hover.variable?.description ? /* @__PURE__ */ jsxRuntime.jsx(react$1.Box, { className: VariableTextEditor_default.popoverDesc, children: hover.variable.description }) : !hover.variable ? /* @__PURE__ */ jsxRuntime.jsx(react$1.Box, { className: VariableTextEditor_default.popoverDesc, children: "This variable is not defined in the current environment." }) : null
+        ]
+      }
+    ) : null;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref: anchorRef,
+        style: {
+          minWidth: 0,
+          width: "100%",
+          height: expansionMode === "overlay" ? safeMinHeight : void 0
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          react$1.Box,
+          {
+            ref: hostRef,
+            className: [VariableTextEditor_default.root, className ?? ""].filter(Boolean).join(" "),
+            style: { ...rootStyle, ...overlayStyle },
+            "data-focused": focused ? "" : void 0,
+            "data-wrapped": focused && wrapped ? "" : void 0,
+            "data-multiline": allowLineBreaks ? "" : void 0,
+            "data-disabled": disabled ? "" : void 0,
+            "data-readonly": readOnly ? "" : void 0,
+            onPointerEnter: handleHostPointerEnter,
+            onPointerMove: handlePointerMove,
+            onPointerLeave: handleHostPointerLeave,
+            children: popoverNode
+          }
+        )
+      }
+    );
+  }
+);
+VariableTextEditor.displayName = "VariableTextEditor";
+
+exports.VariableTextEditor = VariableTextEditor;