@uniformdev/uniform-mcp 20.14.2-alpha.35 → 20.14.2-alpha.50

package/README.md

@@ -4,7 +4,6 @@ A stdio-transport MCP server which allows you to manipulate Uniform entities.
 
 Part of the [Uniform Platform](https://uniform.app). See our [documentation](https://docs.uniform.app) for more details.
 
-
 ### Setup
 
 #### Uniform Context
@@ -14,7 +13,7 @@ For Cursor, this belongs in `.cursor/rules/*.mdc`.
 
 #### Register MCP server
 
-* Add the following to `.cursor/mcp.json` (for other editors, this should be easily convertible)
+- Add the following to `.cursor/mcp.json` (for other editors, this should be easily convertible)
 
 ```
 {
@@ -26,8 +25,9 @@ For Cursor, this belongs in `.cursor/rules/*.mdc`.
       "env": {
         "UNIFORM_API_KEY": "your-api-key",
         "UNIFORM_PROJECT_ID": "your-project-id",
-        // optional, only needed if your host is not uniform.app (e.g. EU users)
+        // optional, only needed if your API host is not the default (e.g. EU users, developers)
         "UNIFORM_API_HOST": "https://uniform.app",
+        "UNIFORM_AI_API_HOST": "https://ai.uniform.global"
       }
     }
   }
@@ -35,7 +35,7 @@ For Cursor, this belongs in `.cursor/rules/*.mdc`.
 
 ```
 
-* Enable the MCP server if necessary.
+- Enable the MCP server if necessary.
 
 Note: if you are developing against this mcp server, you must use `node` with args `../path/to/this-package-source/dist/index.js` - npx does not support local packages. If your Uniform API host is self-signed, `NODE_TLS_REJECT_UNAUTHORIZED: 0` env var works, but do not use in production.
 
@@ -46,4 +46,4 @@ Pattern editing supports a limited subset of patterns. Specifically:
 - Locale support is rudimentary (cannot enable or disable locales, but can change existing localized param values)
 - Conditional values are not supported
 - Inserting other nested patterns is not supported
-- Editing overrides is not supported
+- Editing overrides is not supported

package/dist/LexicalComposer.dev-YZLZHPHB.mjs

@@ -0,0 +1,104 @@
+import {
+  LexicalComposerContext,
+  createLexicalComposerContext
+} from "./chunk-YYOZYEGT.mjs";
+import {
+  require_jsx_runtime
+} from "./chunk-ZX6ALARP.mjs";
+import {
+  require_react
+} from "./chunk-JAKLC22G.mjs";
+import {
+  __toESM
+} from "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/.pnpm/@lexical+react@0.25.0_react-dom@18.3.1_react@18.3.1_yjs@13.6.24/node_modules/@lexical/react/LexicalComposer.dev.mjs
+var import_react = __toESM(require_react(), 1);
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+import { createEditor, $getRoot, $createParagraphNode, $getSelection } from "lexical";
+var CAN_USE_DOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+var useLayoutEffectImpl = CAN_USE_DOM ? import_react.useLayoutEffect : import_react.useEffect;
+var HISTORY_MERGE_OPTIONS = {
+  tag: "history-merge"
+};
+function LexicalComposer({
+  initialConfig,
+  children
+}) {
+  const composerContext = (0, import_react.useMemo)(
+    () => {
+      const {
+        theme,
+        namespace,
+        nodes,
+        onError,
+        editorState: initialEditorState,
+        html
+      } = initialConfig;
+      const context = createLexicalComposerContext(null, theme);
+      const editor = createEditor({
+        editable: initialConfig.editable,
+        html,
+        namespace,
+        nodes,
+        onError: (error) => onError(error, editor),
+        theme
+      });
+      initializeEditor(editor, initialEditorState);
+      return [editor, context];
+    },
+    // We only do this for init
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  useLayoutEffectImpl(() => {
+    const isEditable = initialConfig.editable;
+    const [editor] = composerContext;
+    editor.setEditable(isEditable !== void 0 ? isEditable : true);
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LexicalComposerContext.Provider, {
+    value: composerContext,
+    children
+  });
+}
+function initializeEditor(editor, initialEditorState) {
+  if (initialEditorState === null) {
+    return;
+  } else if (initialEditorState === void 0) {
+    editor.update(() => {
+      const root = $getRoot();
+      if (root.isEmpty()) {
+        const paragraph = $createParagraphNode();
+        root.append(paragraph);
+        const activeElement = CAN_USE_DOM ? document.activeElement : null;
+        if ($getSelection() !== null || activeElement !== null && activeElement === editor.getRootElement()) {
+          paragraph.select();
+        }
+      }
+    }, HISTORY_MERGE_OPTIONS);
+  } else if (initialEditorState !== null) {
+    switch (typeof initialEditorState) {
+      case "string": {
+        const parsedEditorState = editor.parseEditorState(initialEditorState);
+        editor.setEditorState(parsedEditorState, HISTORY_MERGE_OPTIONS);
+        break;
+      }
+      case "object": {
+        editor.setEditorState(initialEditorState, HISTORY_MERGE_OPTIONS);
+        break;
+      }
+      case "function": {
+        editor.update(() => {
+          const root = $getRoot();
+          if (root.isEmpty()) {
+            initialEditorState(editor);
+          }
+        }, HISTORY_MERGE_OPTIONS);
+        break;
+      }
+    }
+  }
+}
+export {
+  LexicalComposer
+};

package/dist/LexicalComposer.prod-GQ6E4XLB.mjs

@@ -0,0 +1,59 @@
+import {
+  LexicalComposerContext,
+  createLexicalComposerContext
+} from "./chunk-YYOZYEGT.mjs";
+import {
+  require_jsx_runtime
+} from "./chunk-ZX6ALARP.mjs";
+import {
+  require_react
+} from "./chunk-JAKLC22G.mjs";
+import {
+  __toESM
+} from "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/.pnpm/@lexical+react@0.25.0_react-dom@18.3.1_react@18.3.1_yjs@13.6.24/node_modules/@lexical/react/LexicalComposer.prod.mjs
+var import_react = __toESM(require_react(), 1);
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+import { createEditor as o, $getRoot as n, $createParagraphNode as i, $getSelection as r } from "lexical";
+var s = "undefined" != typeof window && void 0 !== window.document && void 0 !== window.document.createElement;
+var m = s ? import_react.useLayoutEffect : import_react.useEffect;
+var u = { tag: "history-merge" };
+function p({ initialConfig: a2, children: c2 }) {
+  const p2 = (0, import_react.useMemo)(() => {
+    const { theme: t, namespace: c3, nodes: l2, onError: d2, editorState: m2, html: p3 } = a2, f = createLexicalComposerContext(null, t), E = o({ editable: a2.editable, html: p3, namespace: c3, nodes: l2, onError: (e) => d2(e, E), theme: t });
+    return function(e, t2) {
+      if (null === t2) return;
+      if (void 0 === t2) e.update(() => {
+        const t3 = n();
+        if (t3.isEmpty()) {
+          const o2 = i();
+          t3.append(o2);
+          const n2 = s ? document.activeElement : null;
+          (null !== r() || null !== n2 && n2 === e.getRootElement()) && o2.select();
+        }
+      }, u);
+      else if (null !== t2) switch (typeof t2) {
+        case "string": {
+          const o2 = e.parseEditorState(t2);
+          e.setEditorState(o2, u);
+          break;
+        }
+        case "object":
+          e.setEditorState(t2, u);
+          break;
+        case "function":
+          e.update(() => {
+            n().isEmpty() && t2(e);
+          }, u);
+      }
+    }(E, m2), [E, f];
+  }, []);
+  return m(() => {
+    const e = a2.editable, [t] = p2;
+    t.setEditable(void 0 === e || e);
+  }, []), (0, import_jsx_runtime.jsx)(LexicalComposerContext.Provider, { value: p2, children: c2 });
+}
+export {
+  p as LexicalComposer
+};

package/dist/LexicalComposerContext.dev-OXMYTAIK.mjs

@@ -0,0 +1,39 @@
+import {
+  require_react
+} from "./chunk-JAKLC22G.mjs";
+import {
+  __toESM
+} from "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/.pnpm/@lexical+react@0.25.0_react-dom@18.3.1_react@18.3.1_yjs@13.6.24/node_modules/@lexical/react/LexicalComposerContext.dev.mjs
+var import_react = __toESM(require_react(), 1);
+var LexicalComposerContext = /* @__PURE__ */ (0, import_react.createContext)(null);
+function createLexicalComposerContext(parent, theme) {
+  let parentContext = null;
+  if (parent != null) {
+    parentContext = parent[1];
+  }
+  function getTheme() {
+    if (theme != null) {
+      return theme;
+    }
+    return parentContext != null ? parentContext.getTheme() : null;
+  }
+  return {
+    getTheme
+  };
+}
+function useLexicalComposerContext() {
+  const composerContext = (0, import_react.useContext)(LexicalComposerContext);
+  if (composerContext == null) {
+    {
+      throw Error(`LexicalComposerContext.useLexicalComposerContext: cannot find a LexicalComposerContext`);
+    }
+  }
+  return composerContext;
+}
+export {
+  LexicalComposerContext,
+  createLexicalComposerContext,
+  useLexicalComposerContext
+};

package/dist/LexicalComposerContext.prod-B6MGULHP.mjs

@@ -0,0 +1,34 @@
+import {
+  require_react
+} from "./chunk-JAKLC22G.mjs";
+import {
+  __toESM
+} from "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/.pnpm/@lexical+react@0.25.0_react-dom@18.3.1_react@18.3.1_yjs@13.6.24/node_modules/@lexical/react/LexicalComposerContext.prod.mjs
+var import_react = __toESM(require_react(), 1);
+function r(e2) {
+  return e2 && e2.__esModule && Object.prototype.hasOwnProperty.call(e2, "default") ? e2.default : e2;
+}
+var t = r(function(e2) {
+  const n2 = new URL("https://lexical.dev/docs/error"), r2 = new URLSearchParams();
+  r2.append("code", e2);
+  for (let e3 = 1; e3 < arguments.length; e3++) r2.append("v", arguments[e3]);
+  throw n2.search = r2.toString(), Error(`Minified Lexical error #${e2}; visit ${n2.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`);
+});
+var l = (0, import_react.createContext)(null);
+function o(e2, n2) {
+  let r2 = null;
+  return null != e2 && (r2 = e2[1]), { getTheme: function() {
+    return null != n2 ? n2 : null != r2 ? r2.getTheme() : null;
+  } };
+}
+function u() {
+  const e2 = (0, import_react.useContext)(l);
+  return null == e2 && t(8), e2;
+}
+export {
+  l as LexicalComposerContext,
+  o as createLexicalComposerContext,
+  u as useLexicalComposerContext
+};

package/dist/LexicalContentEditable.dev-HSZEZVX6.mjs

@@ -0,0 +1,176 @@
+import {
+  $canShowPlaceholderCurry
+} from "./chunk-BPEABKCT.mjs";
+import {
+  mergeRegister
+} from "./chunk-3UUF6GA6.mjs";
+import {
+  useLexicalComposerContext
+} from "./chunk-YYOZYEGT.mjs";
+import {
+  require_jsx_runtime
+} from "./chunk-ZX6ALARP.mjs";
+import {
+  require_react
+} from "./chunk-JAKLC22G.mjs";
+import {
+  __toESM
+} from "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/.pnpm/@lexical+react@0.25.0_react-dom@18.3.1_react@18.3.1_yjs@13.6.24/node_modules/@lexical/react/LexicalContentEditable.dev.mjs
+var import_react = __toESM(require_react(), 1);
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var CAN_USE_DOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+var useLayoutEffectImpl = CAN_USE_DOM ? import_react.useLayoutEffect : import_react.useEffect;
+function mergeRefs(...refs) {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        ref.current = value;
+      }
+    });
+  };
+}
+function ContentEditableElementImpl({
+  editor,
+  ariaActiveDescendant,
+  ariaAutoComplete,
+  ariaControls,
+  ariaDescribedBy,
+  ariaErrorMessage,
+  ariaExpanded,
+  ariaInvalid,
+  ariaLabel,
+  ariaLabelledBy,
+  ariaMultiline,
+  ariaOwns,
+  ariaRequired,
+  autoCapitalize,
+  className,
+  id,
+  role = "textbox",
+  spellCheck = true,
+  style,
+  tabIndex,
+  "data-testid": testid,
+  ...rest
+}, ref) {
+  const [isEditable, setEditable] = (0, import_react.useState)(editor.isEditable());
+  const handleRef = (0, import_react.useCallback)((rootElement) => {
+    if (rootElement && rootElement.ownerDocument && rootElement.ownerDocument.defaultView) {
+      editor.setRootElement(rootElement);
+    } else {
+      editor.setRootElement(null);
+    }
+  }, [editor]);
+  const mergedRefs = (0, import_react.useMemo)(() => mergeRefs(ref, handleRef), [handleRef, ref]);
+  useLayoutEffectImpl(() => {
+    setEditable(editor.isEditable());
+    return editor.registerEditableListener((currentIsEditable) => {
+      setEditable(currentIsEditable);
+    });
+  }, [editor]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+    "aria-activedescendant": isEditable ? ariaActiveDescendant : void 0,
+    "aria-autocomplete": isEditable ? ariaAutoComplete : "none",
+    "aria-controls": isEditable ? ariaControls : void 0,
+    "aria-describedby": ariaDescribedBy,
+    ...ariaErrorMessage != null ? {
+      "aria-errormessage": ariaErrorMessage
+    } : {},
+    "aria-expanded": isEditable && role === "combobox" ? !!ariaExpanded : void 0,
+    ...ariaInvalid != null ? {
+      "aria-invalid": ariaInvalid
+    } : {},
+    "aria-label": ariaLabel,
+    "aria-labelledby": ariaLabelledBy,
+    "aria-multiline": ariaMultiline,
+    "aria-owns": isEditable ? ariaOwns : void 0,
+    "aria-readonly": isEditable ? void 0 : true,
+    "aria-required": ariaRequired,
+    autoCapitalize,
+    className,
+    contentEditable: isEditable,
+    "data-testid": testid,
+    id,
+    ref: mergedRefs,
+    role: isEditable ? role : void 0,
+    spellCheck,
+    style,
+    tabIndex,
+    ...rest
+  });
+}
+var ContentEditableElement = /* @__PURE__ */ (0, import_react.forwardRef)(ContentEditableElementImpl);
+function canShowPlaceholderFromCurrentEditorState(editor) {
+  const currentCanShowPlaceholder = editor.getEditorState().read($canShowPlaceholderCurry(editor.isComposing()));
+  return currentCanShowPlaceholder;
+}
+function useCanShowPlaceholder(editor) {
+  const [canShowPlaceholder, setCanShowPlaceholder] = (0, import_react.useState)(() => canShowPlaceholderFromCurrentEditorState(editor));
+  useLayoutEffectImpl(() => {
+    function resetCanShowPlaceholder() {
+      const currentCanShowPlaceholder = canShowPlaceholderFromCurrentEditorState(editor);
+      setCanShowPlaceholder(currentCanShowPlaceholder);
+    }
+    resetCanShowPlaceholder();
+    return mergeRegister(editor.registerUpdateListener(() => {
+      resetCanShowPlaceholder();
+    }), editor.registerEditableListener(() => {
+      resetCanShowPlaceholder();
+    }));
+  }, [editor]);
+  return canShowPlaceholder;
+}
+var ContentEditable = /* @__PURE__ */ (0, import_react.forwardRef)(ContentEditableImpl);
+function ContentEditableImpl(props, ref) {
+  const {
+    placeholder,
+    ...rest
+  } = props;
+  const [editor] = useLexicalComposerContext();
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, {
+    children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContentEditableElement, {
+      editor,
+      ...rest,
+      ref
+    }), placeholder != null && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Placeholder, {
+      editor,
+      content: placeholder
+    })]
+  });
+}
+function Placeholder({
+  content,
+  editor
+}) {
+  const showPlaceholder = useCanShowPlaceholder(editor);
+  const [isEditable, setEditable] = (0, import_react.useState)(editor.isEditable());
+  (0, import_react.useLayoutEffect)(() => {
+    setEditable(editor.isEditable());
+    return editor.registerEditableListener((currentIsEditable) => {
+      setEditable(currentIsEditable);
+    });
+  }, [editor]);
+  if (!showPlaceholder) {
+    return null;
+  }
+  let placeholder = null;
+  if (typeof content === "function") {
+    placeholder = content(isEditable);
+  } else if (content !== null) {
+    placeholder = content;
+  }
+  if (placeholder === null) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+    "aria-hidden": true,
+    children: placeholder
+  });
+}
+export {
+  ContentEditable
+};

package/dist/LexicalContentEditable.prod-MA4E5ZUO.mjs

@@ -0,0 +1,70 @@
+import {
+  $canShowPlaceholderCurry
+} from "./chunk-BPEABKCT.mjs";
+import {
+  mergeRegister
+} from "./chunk-3UUF6GA6.mjs";
+import {
+  useLexicalComposerContext
+} from "./chunk-YYOZYEGT.mjs";
+import {
+  require_jsx_runtime
+} from "./chunk-ZX6ALARP.mjs";
+import {
+  require_react
+} from "./chunk-JAKLC22G.mjs";
+import {
+  __toESM
+} from "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/.pnpm/@lexical+react@0.25.0_react-dom@18.3.1_react@18.3.1_yjs@13.6.24/node_modules/@lexical/react/LexicalContentEditable.prod.mjs
+var import_react = __toESM(require_react(), 1);
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var m = "undefined" != typeof window && void 0 !== window.document && void 0 !== window.document.createElement ? import_react.useLayoutEffect : import_react.useEffect;
+function f({ editor: e, ariaActiveDescendant: t2, ariaAutoComplete: i2, ariaControls: a2, ariaDescribedBy: d2, ariaErrorMessage: c2, ariaExpanded: s, ariaInvalid: u, ariaLabel: f2, ariaLabelledBy: b2, ariaMultiline: p2, ariaOwns: x2, ariaRequired: E2, autoCapitalize: v2, className: w, id: y, role: C = "textbox", spellCheck: g = true, style: h, tabIndex: L, "data-testid": D, ...I }, R) {
+  const [k, q] = (0, import_react.useState)(e.isEditable()), z = (0, import_react.useCallback)((t3) => {
+    t3 && t3.ownerDocument && t3.ownerDocument.defaultView ? e.setRootElement(t3) : e.setRootElement(null);
+  }, [e]), A = (0, import_react.useMemo)(() => /* @__PURE__ */ function(...e2) {
+    return (t3) => {
+      e2.forEach((e3) => {
+        "function" == typeof e3 ? e3(t3) : null != e3 && (e3.current = t3);
+      });
+    };
+  }(R, z), [z, R]);
+  return m(() => (q(e.isEditable()), e.registerEditableListener((e2) => {
+    q(e2);
+  })), [e]), (0, import_jsx_runtime.jsx)("div", { "aria-activedescendant": k ? t2 : void 0, "aria-autocomplete": k ? i2 : "none", "aria-controls": k ? a2 : void 0, "aria-describedby": d2, ...null != c2 ? { "aria-errormessage": c2 } : {}, "aria-expanded": k && "combobox" === C ? !!s : void 0, ...null != u ? { "aria-invalid": u } : {}, "aria-label": f2, "aria-labelledby": b2, "aria-multiline": p2, "aria-owns": k ? x2 : void 0, "aria-readonly": !k || void 0, "aria-required": E2, autoCapitalize: v2, className: w, contentEditable: k, "data-testid": D, id: y, ref: A, role: k ? C : void 0, spellCheck: g, style: h, tabIndex: L, ...I });
+}
+var b = (0, import_react.forwardRef)(f);
+function p(e) {
+  return e.getEditorState().read($canShowPlaceholderCurry(e.isComposing()));
+}
+var x = (0, import_react.forwardRef)(E);
+function E(t2, i2) {
+  const { placeholder: a2, ...r2 } = t2, [n2] = useLexicalComposerContext();
+  return (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [(0, import_jsx_runtime.jsx)(b, { editor: n2, ...r2, ref: i2 }), null != a2 && (0, import_jsx_runtime.jsx)(v, { editor: n2, content: a2 })] });
+}
+function v({ content: e, editor: i2 }) {
+  const a2 = function(e2) {
+    const [t2, i3] = (0, import_react.useState)(() => p(e2));
+    return m(() => {
+      function t3() {
+        const t4 = p(e2);
+        i3(t4);
+      }
+      return t3(), mergeRegister(e2.registerUpdateListener(() => {
+        t3();
+      }), e2.registerEditableListener(() => {
+        t3();
+      }));
+    }, [e2]), t2;
+  }(i2), [n2, o2] = (0, import_react.useState)(i2.isEditable());
+  if ((0, import_react.useLayoutEffect)(() => (o2(i2.isEditable()), i2.registerEditableListener((e2) => {
+    o2(e2);
+  })), [i2]), !a2) return null;
+  let d2 = null;
+  return "function" == typeof e ? d2 = e(n2) : null !== e && (d2 = e), null === d2 ? null : (0, import_jsx_runtime.jsx)("div", { "aria-hidden": true, children: d2 });
+}
+export {
+  x as ContentEditable
+};

package/dist/LexicalDragon.dev-FLAESERJ.mjs

@@ -0,0 +1,70 @@
+import "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/.pnpm/@lexical+dragon@0.25.0/node_modules/@lexical/dragon/LexicalDragon.dev.mjs
+import { $getSelection, $isRangeSelection, $isTextNode } from "lexical";
+function registerDragonSupport(editor) {
+  const origin = window.location.origin;
+  const handler = (event) => {
+    if (event.origin !== origin) {
+      return;
+    }
+    const rootElement = editor.getRootElement();
+    if (document.activeElement !== rootElement) {
+      return;
+    }
+    const data = event.data;
+    if (typeof data === "string") {
+      let parsedData;
+      try {
+        parsedData = JSON.parse(data);
+      } catch (e) {
+        return;
+      }
+      if (parsedData && parsedData.protocol === "nuanria_messaging" && parsedData.type === "request") {
+        const payload = parsedData.payload;
+        if (payload && payload.functionId === "makeChanges") {
+          const args = payload.args;
+          if (args) {
+            const [elementStart, elementLength, text, selStart, selLength, formatCommand] = args;
+            editor.update(() => {
+              const selection = $getSelection();
+              if ($isRangeSelection(selection)) {
+                const anchor = selection.anchor;
+                let anchorNode = anchor.getNode();
+                let setSelStart = 0;
+                let setSelEnd = 0;
+                if ($isTextNode(anchorNode)) {
+                  if (elementStart >= 0 && elementLength >= 0) {
+                    setSelStart = elementStart;
+                    setSelEnd = elementStart + elementLength;
+                    selection.setTextNodeRange(anchorNode, setSelStart, anchorNode, setSelEnd);
+                  }
+                }
+                if (setSelStart !== setSelEnd || text !== "") {
+                  selection.insertRawText(text);
+                  anchorNode = anchor.getNode();
+                }
+                if ($isTextNode(anchorNode)) {
+                  setSelStart = selStart;
+                  setSelEnd = selStart + selLength;
+                  const anchorNodeTextLength = anchorNode.getTextContentSize();
+                  setSelStart = setSelStart > anchorNodeTextLength ? anchorNodeTextLength : setSelStart;
+                  setSelEnd = setSelEnd > anchorNodeTextLength ? anchorNodeTextLength : setSelEnd;
+                  selection.setTextNodeRange(anchorNode, setSelStart, anchorNode, setSelEnd);
+                }
+                event.stopImmediatePropagation();
+              }
+            });
+          }
+        }
+      }
+    }
+  };
+  window.addEventListener("message", handler, true);
+  return () => {
+    window.removeEventListener("message", handler, true);
+  };
+}
+export {
+  registerDragonSupport
+};

package/dist/LexicalDragon.prod-WGTSU75T.mjs

@@ -0,0 +1,48 @@
+import "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/.pnpm/@lexical+dragon@0.25.0/node_modules/@lexical/dragon/LexicalDragon.prod.mjs
+import { $getSelection as e, $isRangeSelection as t, $isTextNode as n } from "lexical";
+function o(o2) {
+  const i = window.location.origin, a = (a2) => {
+    if (a2.origin !== i) return;
+    const r = o2.getRootElement();
+    if (document.activeElement !== r) return;
+    const s = a2.data;
+    if ("string" == typeof s) {
+      let i2;
+      try {
+        i2 = JSON.parse(s);
+      } catch (e2) {
+        return;
+      }
+      if (i2 && "nuanria_messaging" === i2.protocol && "request" === i2.type) {
+        const r2 = i2.payload;
+        if (r2 && "makeChanges" === r2.functionId) {
+          const i3 = r2.args;
+          if (i3) {
+            const [r3, s2, c, g, d, f] = i3;
+            o2.update(() => {
+              const o3 = e();
+              if (t(o3)) {
+                const e2 = o3.anchor;
+                let t2 = e2.getNode(), i4 = 0, f2 = 0;
+                if (n(t2) && r3 >= 0 && s2 >= 0 && (i4 = r3, f2 = r3 + s2, o3.setTextNodeRange(t2, i4, t2, f2)), i4 === f2 && "" === c || (o3.insertRawText(c), t2 = e2.getNode()), n(t2)) {
+                  i4 = g, f2 = g + d;
+                  const e3 = t2.getTextContentSize();
+                  i4 = i4 > e3 ? e3 : i4, f2 = f2 > e3 ? e3 : f2, o3.setTextNodeRange(t2, i4, t2, f2);
+                }
+                a2.stopImmediatePropagation();
+              }
+            });
+          }
+        }
+      }
+    }
+  };
+  return window.addEventListener("message", a, true), () => {
+    window.removeEventListener("message", a, true);
+  };
+}
+export {
+  o as registerDragonSupport
+};