@soul-refiner/design-system 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/node_modules/@udecode/plate-core/dist/index.js

@@ -0,0 +1,2656 @@
+'use strict';
+
+var React = require('react');
+var index = require('../../../jotai-x/dist/index.js');
+var reactHotkeysHook_esm = require('../../../react-hotkeys-hook/dist/react-hotkeys-hook.esm.js');
+var index$1 = require('../../../zustand-x/dist/index.js');
+var index$6 = require('../../slate/dist/index.js');
+var index$4 = require('../../slate-react/dist/index.js');
+var index$7 = require('../../slate-utils/dist/index.js');
+var index$3 = require('../../utils/dist/index.js');
+var defaultsDeep = require('../../../lodash/defaultsDeep.js');
+var slateHistory = require('slate-history');
+var slateReact = require('slate-react');
+var slateHyperscript = require('slate-hyperscript');
+var castArray = require('../../../lodash/castArray.js');
+var keyBy = require('../../../lodash/keyBy.js');
+var merge = require('../../../lodash/merge.js');
+var values = require('../../../lodash/values.js');
+var cloneDeep = require('../../../lodash/cloneDeep.js');
+var clsx_m = require('../../../clsx/dist/clsx.m.js');
+var index$2 = require('../../../is-hotkey/lib/index.js');
+require('../../../lodash/_Stack.js');
+require('../../../lodash/_SetCache.js');
+require('../../../lodash/_equalByTag.js');
+require('../../../lodash/isArguments.js');
+require('../../../lodash/isBuffer.js');
+require('../../../lodash/isTypedArray.js');
+require('../../../lodash/_baseGetTag.js');
+require('../../../lodash/_getTag.js');
+var slate = require('slate');
+var omit = require('../../../lodash/omit.js');
+var index$5 = require('../../../use-deep-compare/dist-web/index.js');
+var index_modern = require('../../../jotai-optics/dist/index.modern.js');
+var utils = require('../../../jotai/esm/vanilla/utils.js');
+var vanilla = require('../../../jotai/esm/vanilla.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function DefaultLeaf(_a) {
+  var _b = _a, {
+    attributes,
+    children,
+    text,
+    leaf,
+    editor,
+    nodeProps
+  } = _b, props = __objRest(_b, [
+    "attributes",
+    "children",
+    "text",
+    "leaf",
+    "editor",
+    "nodeProps"
+  ]);
+  return /* @__PURE__ */ React__default.default.createElement("span", __spreadValues(__spreadValues({}, attributes), props), children);
+}
+
+// src/stores/element/useElementStore.ts
+var SCOPE_ELEMENT = "element";
+var initialState = {
+  element: null
+};
+var { useElementStore, ElementProvider } = index.createAtomStore(
+  initialState,
+  { name: "element" }
+);
+
+// src/stores/element/useElement.ts
+var useElement = (pluginKey = SCOPE_ELEMENT) => {
+  const value = useElementStore(pluginKey).get.element();
+  if (!value) {
+    console.warn(
+      `The \`useElement(pluginKey)\` hook must be used inside the node component's context`
+    );
+    return {};
+  }
+  return value;
+};
+
+// src/stores/event-editor/eventEditorStore.ts
+var eventEditorStore = index$1.createZustandStore("event-editor")({
+  blur: null,
+  focus: null,
+  last: null
+});
+var eventEditorActions = eventEditorStore.set;
+var eventEditorSelectors = eventEditorStore.get;
+eventEditorStore.use;
+var applyDeepToNodes = ({
+  node,
+  path = [],
+  source,
+  apply,
+  query
+}) => {
+  const entry = [node, path];
+  if (index$6.queryNode(entry, query)) {
+    if (source instanceof Function) {
+      apply(node, source());
+    } else {
+      apply(node, source);
+    }
+  }
+  if (!index$6.isAncestor(node))
+    return;
+  node.children.forEach((child, index) => {
+    applyDeepToNodes({
+      node: child,
+      path: path.concat([index]),
+      source,
+      apply,
+      query
+    });
+  });
+};
+var resetEditorChildren = (editor, options) => {
+  index$7.replaceNodeChildren(editor, __spreadValues({
+    at: [],
+    nodes: editor.childrenFactory()
+  }, options));
+};
+
+// src/transforms/resetEditor.ts
+var resetEditor = (editor) => {
+  const isFocused = index$4.isEditorFocused(editor);
+  resetEditorChildren(editor);
+  editor.history.undos = [];
+  editor.history.redos = [];
+  editor.operations = [];
+  if (isFocused) {
+    index$4.focusEditorEdge(editor, { edge: "start" });
+  }
+};
+
+// src/constants/ELEMENT_DEFAULT.ts
+var ELEMENT_DEFAULT = "p";
+
+// src/utils/getPluginsByKey.ts
+var getPluginsByKey = (editor) => {
+  var _a;
+  return (_a = editor == null ? void 0 : editor.pluginsByKey) != null ? _a : {};
+};
+
+// src/utils/getPlugin.ts
+var getPlugin = (editor, key) => {
+  var _a;
+  return (_a = getPluginsByKey(editor)[key]) != null ? _a : { key };
+};
+
+// src/utils/getPluginType.ts
+var getPluginType = (editor, key) => {
+  var _a, _b;
+  return (_b = (_a = getPlugin(editor, key).type) != null ? _a : key) != null ? _b : "";
+};
+var overridePluginsByKey = (plugin, overrideByKey = {}, nested = false) => {
+  var _b;
+  if (overrideByKey[plugin.key]) {
+    const _a = overrideByKey[plugin.key], {
+      plugins: pluginOverridesPlugins,
+      then: pluginOverridesThen
+    } = _a, pluginOverrides = __objRest(_a, [
+      "plugins",
+      "then"
+    ]);
+    plugin = defaultsDeep.default(pluginOverrides, plugin);
+    if (!nested) {
+      pluginOverridesPlugins == null ? void 0 : pluginOverridesPlugins.forEach((pOverrides) => {
+        if (!plugin.plugins)
+          plugin.plugins = [];
+        const found = plugin.plugins.find((p) => p.key === pOverrides.key);
+        if (!found)
+          plugin.plugins.push(pOverrides);
+      });
+    }
+  }
+  if (plugin.plugins) {
+    plugin.plugins = plugin.plugins.map(
+      (p) => overridePluginsByKey(p, overrideByKey, true)
+    );
+  }
+  const { then } = plugin;
+  if (then) {
+    if (plugin._thenReplaced === void 0) {
+      plugin._thenReplaced = 0;
+    }
+    if (plugin._thenReplaced < 3) {
+      plugin.then = (editor, p) => {
+        const pluginThen = __spreadValues({ key: plugin.key }, then(editor, p));
+        return defaultsDeep.default(
+          overridePluginsByKey(pluginThen, overrideByKey),
+          pluginThen
+        );
+      };
+      plugin._thenReplaced++;
+    }
+  } else if ((_b = overrideByKey[plugin.key]) == null ? void 0 : _b.then) {
+    plugin.then = overrideByKey[plugin.key].then;
+  }
+  return plugin;
+};
+
+// src/utils/createPluginFactory.ts
+var createPluginFactory = (defaultPlugin) => (override, overrideByKey = {}) => {
+  overrideByKey[defaultPlugin.key] = override;
+  return overridePluginsByKey(
+    __spreadValues({}, defaultPlugin),
+    overrideByKey
+  );
+};
+
+// src/plugins/createDeserializeAstPlugin.ts
+var KEY_DESERIALIZE_AST = "deserializeAst";
+var createDeserializeAstPlugin = createPluginFactory({
+  key: KEY_DESERIALIZE_AST,
+  editor: {
+    insertData: {
+      format: "application/x-slate-fragment",
+      getFragment: ({ data }) => {
+        const decoded = decodeURIComponent(window.atob(data));
+        let parsed;
+        try {
+          parsed = JSON.parse(decoded);
+        } catch (error) {
+        }
+        return parsed;
+      }
+    }
+  }
+});
+var getBlockAbove = (editor, options = {}) => index$6.getAboveNode(editor, __spreadProps(__spreadValues({}, options), {
+  block: true
+}));
+var isSelectionAtBlockStart = (editor, options) => {
+  var _a;
+  const { selection } = editor;
+  if (!selection)
+    return false;
+  const path = (_a = getBlockAbove(editor, options)) == null ? void 0 : _a[1];
+  if (!path)
+    return false;
+  return index$6.isStartPoint(editor, selection.focus, path) || index$6.isExpanded(editor.selection) && index$6.isStartPoint(editor, selection.anchor, path);
+};
+var removeSelectionMark = (editor) => {
+  const marks = index$6.getMarks(editor);
+  if (!marks)
+    return;
+  Object.keys(marks).forEach((key) => {
+    index$6.removeEditorMark(editor, key);
+  });
+};
+var KEY_EDITOR_PROTOCOL = "editorProtocol";
+var withEditorProtocol = (editor) => {
+  const { deleteBackward, deleteForward, deleteFragment } = editor;
+  const resetMarks = () => {
+    if (isSelectionAtBlockStart(editor)) {
+      removeSelectionMark(editor);
+    }
+  };
+  editor.deleteBackward = (unit) => {
+    deleteBackward(unit);
+    resetMarks();
+  };
+  editor.deleteForward = (unit) => {
+    deleteForward(unit);
+    resetMarks();
+  };
+  editor.deleteFragment = (direction) => {
+    deleteFragment(direction);
+    resetMarks();
+  };
+  return editor;
+};
+var createEditorProtocolPlugin = createPluginFactory({
+  key: KEY_EDITOR_PROTOCOL,
+  withOverrides: withEditorProtocol
+});
+
+// src/plugins/createEventEditorPlugin.ts
+var KEY_EVENT_EDITOR = "event-editor";
+var createEventEditorPlugin = createPluginFactory({
+  key: KEY_EVENT_EDITOR,
+  handlers: {
+    onFocus: (editor) => () => {
+      eventEditorActions.focus(editor.id);
+    },
+    onBlur: (editor) => () => {
+      const focus = eventEditorSelectors.focus();
+      if (focus === editor.id) {
+        eventEditorActions.focus(null);
+      }
+      eventEditorActions.blur(editor.id);
+    }
+  }
+});
+var withTHistory = (editor) => slateHistory.withHistory(editor);
+var createHistoryPlugin = createPluginFactory({
+  key: "history",
+  withOverrides: withTHistory
+});
+
+// src/plugins/createInlineVoidPlugin.ts
+var KEY_INLINE_VOID = "inline-void";
+var withInlineVoid = (editor) => {
+  const { isInline, isVoid, markableVoid } = editor;
+  const voidTypes = [];
+  const inlineTypes = [];
+  const markableVoidTypes = [];
+  editor.plugins.forEach((plugin) => {
+    if (plugin.isInline) {
+      inlineTypes.push(plugin.type);
+    }
+    if (plugin.isVoid) {
+      voidTypes.push(plugin.type);
+    }
+    if (plugin.isMarkableVoid) {
+      markableVoidTypes.push(plugin.type);
+    }
+  });
+  editor.isInline = (element) => {
+    return inlineTypes.includes(element.type) ? true : isInline(element);
+  };
+  editor.isVoid = (element) => {
+    return voidTypes.includes(element.type) ? true : isVoid(element);
+  };
+  editor.markableVoid = (element) => {
+    return markableVoidTypes.includes(element.type) ? true : markableVoid(element);
+  };
+  return editor;
+};
+var createInlineVoidPlugin = createPluginFactory({
+  key: KEY_INLINE_VOID,
+  withOverrides: withInlineVoid
+});
+
+// src/utils/getInjectedPlugins.ts
+var getInjectedPlugins = (editor, plugin) => {
+  const injectedPlugins = [];
+  [...editor.plugins].reverse().forEach((p) => {
+    var _a;
+    const injectedPlugin = (_a = p.inject.pluginsByKey) == null ? void 0 : _a[plugin.key];
+    if (injectedPlugin)
+      injectedPlugins.push(injectedPlugin);
+  });
+  return [plugin, ...injectedPlugins];
+};
+
+// src/utils/pipeInsertDataQuery.ts
+var pipeInsertDataQuery = (plugins, { data, dataTransfer }) => plugins.every((p) => {
+  var _a, _b;
+  const query = (_b = (_a = p.editor) == null ? void 0 : _a.insertData) == null ? void 0 : _b.query;
+  return !query || query({
+    data,
+    dataTransfer
+  });
+});
+var pipeInsertFragment = (editor, injectedPlugins, _a) => {
+  var _b = _a, {
+    fragment
+  } = _b, options = __objRest(_b, [
+    "fragment"
+  ]);
+  index$6.withoutNormalizing(editor, () => {
+    injectedPlugins.some((p) => {
+      var _a2, _b2, _c;
+      return ((_c = (_b2 = (_a2 = p.editor) == null ? void 0 : _a2.insertData) == null ? void 0 : _b2.preInsert) == null ? void 0 : _c.call(_b2, fragment, options)) === true;
+    });
+    editor.insertFragment(fragment);
+  });
+};
+
+// src/utils/pipeTransformData.ts
+var pipeTransformData = (plugins, { data, dataTransfer }) => {
+  plugins.forEach((p) => {
+    var _a, _b;
+    const transformData = (_b = (_a = p.editor) == null ? void 0 : _a.insertData) == null ? void 0 : _b.transformData;
+    if (!transformData)
+      return;
+    data = transformData(data, { dataTransfer });
+  });
+  return data;
+};
+
+// src/utils/pipeTransformFragment.ts
+var pipeTransformFragment = (plugins, _a) => {
+  var _b = _a, {
+    fragment
+  } = _b, options = __objRest(_b, [
+    "fragment"
+  ]);
+  plugins.forEach((p) => {
+    var _a2, _b2;
+    const transformFragment = (_b2 = (_a2 = p.editor) == null ? void 0 : _a2.insertData) == null ? void 0 : _b2.transformFragment;
+    if (!transformFragment)
+      return;
+    fragment = transformFragment(fragment, options);
+  });
+  return fragment;
+};
+
+// src/plugins/createInsertDataPlugin.ts
+var withInsertData = (editor) => {
+  const { insertData } = editor;
+  editor.insertData = (dataTransfer) => {
+    const inserted = [...editor.plugins].reverse().some((plugin) => {
+      const insertDataOptions = plugin.editor.insertData;
+      if (!insertDataOptions)
+        return false;
+      const injectedPlugins = getInjectedPlugins(editor, plugin);
+      const { format, getFragment } = insertDataOptions;
+      if (!format)
+        return false;
+      let data = dataTransfer.getData(format);
+      if (!data)
+        return;
+      if (!pipeInsertDataQuery(injectedPlugins, {
+        data,
+        dataTransfer
+      })) {
+        return false;
+      }
+      data = pipeTransformData(injectedPlugins, {
+        data,
+        dataTransfer
+      });
+      let fragment = getFragment == null ? void 0 : getFragment({
+        data,
+        dataTransfer
+      });
+      if (!(fragment == null ? void 0 : fragment.length))
+        return false;
+      fragment = pipeTransformFragment(injectedPlugins, {
+        fragment,
+        data,
+        dataTransfer
+      });
+      if (fragment.length === 0)
+        return false;
+      pipeInsertFragment(editor, injectedPlugins, {
+        fragment,
+        data,
+        dataTransfer
+      });
+      return true;
+    });
+    if (inserted)
+      return;
+    insertData(dataTransfer);
+  };
+  return editor;
+};
+var KEY_INSERT_DATA = "insertData";
+var createInsertDataPlugin = createPluginFactory({
+  key: KEY_INSERT_DATA,
+  withOverrides: withInsertData
+});
+var KEY_LENGTH = "length";
+var withLength = (editor, { options }) => {
+  const { apply } = editor;
+  editor.apply = (operation) => {
+    index$6.withoutNormalizing(editor, () => {
+      apply(operation);
+      if (options.maxLength) {
+        const length = index$6.getEditorString(editor, []).length;
+        if (length > options.maxLength) {
+          const overflowLength = length - options.maxLength;
+          editor.delete({
+            unit: "character",
+            distance: overflowLength,
+            reverse: true
+          });
+        }
+      }
+    });
+  };
+  return editor;
+};
+var createLengthPlugin = createPluginFactory({
+  key: KEY_LENGTH,
+  withOverrides: withLength
+});
+
+// src/plugins/createNodeFactoryPlugin.ts
+var KEY_NODE_FACTORY = "nodeFactory";
+var createNodeFactoryPlugin = createPluginFactory({
+  key: KEY_NODE_FACTORY,
+  withOverrides: (editor) => {
+    editor.blockFactory = (node) => __spreadValues({
+      type: getPluginType(editor, ELEMENT_DEFAULT),
+      children: [{ text: "" }]
+    }, node);
+    editor.childrenFactory = () => [editor.blockFactory()];
+    return editor;
+  }
+});
+
+// src/plugins/createPrevSelectionPlugin.ts
+var KEY_PREV_SELECTION = "prevSelection";
+var createPrevSelectionPlugin = createPluginFactory({
+  key: KEY_PREV_SELECTION,
+  handlers: {
+    onKeyDown: (editor) => (e) => {
+      e.persist();
+      editor.currentKeyboardEvent = e;
+    }
+  },
+  withOverrides: (editor) => {
+    const { apply } = editor;
+    editor.apply = (operation) => {
+      if (operation.type === "set_selection") {
+        const { properties } = operation;
+        editor.prevSelection = properties;
+        apply(operation);
+        editor.currentKeyboardEvent = null;
+        return;
+      }
+      apply(operation);
+    };
+    return editor;
+  }
+});
+var withTReact = (editor) => slateReact.withReact(editor);
+
+// src/plugins/createReactPlugin.ts
+var createReactPlugin = createPluginFactory({
+  key: "react",
+  withOverrides: withTReact
+});
+var isInlineNode = (editor) => (node) => index$6.isText(node) || index$6.isElement(node) && editor.isInline(node);
+var makeBlockLazy = (type) => () => ({
+  type,
+  children: []
+});
+var hasDifferentChildNodes = (descendants, isInline) => {
+  return descendants.some((descendant, index, arr) => {
+    const prevDescendant = arr[index - 1];
+    if (index !== 0) {
+      return isInline(descendant) !== isInline(prevDescendant);
+    }
+    return false;
+  });
+};
+var normalizeDifferentNodeTypes = (descendants, isInline, makeDefaultBlock) => {
+  const hasDifferentNodes = hasDifferentChildNodes(descendants, isInline);
+  const { fragment } = descendants.reduce(
+    (memo, node) => {
+      if (hasDifferentNodes && isInline(node)) {
+        let block = memo.precedingBlock;
+        if (!block) {
+          block = makeDefaultBlock();
+          memo.precedingBlock = block;
+          memo.fragment.push(block);
+        }
+        block.children.push(node);
+      } else {
+        memo.fragment.push(node);
+        memo.precedingBlock = null;
+      }
+      return memo;
+    },
+    {
+      fragment: [],
+      precedingBlock: null
+    }
+  );
+  return fragment;
+};
+var normalizeEmptyChildren = (descendants) => {
+  if (descendants.length === 0) {
+    return [{ text: "" }];
+  }
+  return descendants;
+};
+var normalize = (descendants, isInline, makeDefaultBlock) => {
+  descendants = normalizeEmptyChildren(descendants);
+  descendants = normalizeDifferentNodeTypes(
+    descendants,
+    isInline,
+    makeDefaultBlock
+  );
+  descendants = descendants.map((node) => {
+    if (index$6.isElement(node)) {
+      return __spreadProps(__spreadValues({}, node), {
+        children: normalize(node.children, isInline, makeDefaultBlock)
+      });
+    }
+    return node;
+  });
+  return descendants;
+};
+var normalizeDescendantsToDocumentFragment = (editor, { descendants }) => {
+  const isInline = isInlineNode(editor);
+  const defaultType = getPluginType(editor, ELEMENT_DEFAULT);
+  const makeDefaultBlock = makeBlockLazy(defaultType);
+  return normalize(descendants, isInline, makeDefaultBlock);
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/collapseString.ts
+var collapseString = (text, {
+  trimStart = "collapse",
+  trimEnd = "collapse",
+  shouldCollapseWhiteSpace = true,
+  whiteSpaceIncludesNewlines = true
+} = {}) => {
+  if (trimStart === "all") {
+    text = text.replace(/^\s+/, "");
+  }
+  if (trimEnd === "single-newline") {
+    text = text.replace(/\n$/, "");
+  }
+  if (shouldCollapseWhiteSpace) {
+    if (whiteSpaceIncludesNewlines) {
+      text = text.replaceAll(/\s+/g, " ");
+    } else {
+      text = text.replaceAll(/[^\S\n\r]+/g, " ");
+      text = text.replaceAll(/^[^\S\n\r]+/gm, "");
+      text = text.replaceAll(/[^\S\n\r]+$/gm, "");
+    }
+  }
+  return text;
+};
+
+// src/plugins/html-deserializer/utils/inlineTagNames.ts
+var inlineTagNames = /* @__PURE__ */ new Set([
+  "A",
+  "ABBR",
+  "B",
+  "BDI",
+  "BDO",
+  "BR",
+  "CITE",
+  "CODE",
+  "DATA",
+  "DFN",
+  "EM",
+  "I",
+  "KBD",
+  "MARK",
+  "Q",
+  "S",
+  "SAMP",
+  "SMALL",
+  "SPAN",
+  "STRONG",
+  "SUB",
+  "SUP",
+  "TIME",
+  "U",
+  "VAR",
+  "WBR",
+  "IMG",
+  "MAP",
+  "TRACK",
+  "VIDEO",
+  "EMBED",
+  "IFRAME",
+  "OBJECT",
+  "PICTURE",
+  "PORTAL",
+  "SOURCE",
+  "svg",
+  "math",
+  "CANVAS",
+  "DEL",
+  "INS",
+  "BUTTON",
+  "INPUT",
+  "LABEL",
+  "METER",
+  "OUTPUT",
+  "PROGRESS",
+  "SELECT",
+  "TEXTAREA",
+  "ACRONYM",
+  "BIG",
+  "CONTENT",
+  "FONT",
+  "IMG",
+  "MARQUEE",
+  "MENUITEM",
+  "NOBR",
+  "SHADOW",
+  "STRIKE",
+  "TT"
+]);
+
+// src/plugins/html-deserializer/utils/isHtmlElement.ts
+var isHtmlElement = (node) => node.nodeType === Node.ELEMENT_NODE;
+
+// src/plugins/html-deserializer/utils/isHtmlInlineElement.ts
+var isHtmlInlineElement = (node) => {
+  if (!isHtmlElement(node))
+    return false;
+  const element = node;
+  const tagNameIsInline = inlineTagNames.has(element.tagName);
+  const displayProperty = element.style.display.split(" ")[0];
+  if (displayProperty === "") {
+    return tagNameIsInline;
+  }
+  if (displayProperty.startsWith("inline")) {
+    return true;
+  }
+  if (displayProperty === "inherit" && element.parentElement) {
+    return isHtmlInlineElement(element.parentElement);
+  }
+  if (["initial", "unset", "revert", "revert-layer", "contents", "none"].includes(
+    displayProperty
+  )) {
+    return tagNameIsInline;
+  }
+  return false;
+};
+
+// src/plugins/html-deserializer/utils/isHtmlText.ts
+var isHtmlText = (node) => node.nodeType === Node.TEXT_NODE;
+
+// src/plugins/html-deserializer/utils/isHtmlBlockElement.ts
+var isHtmlBlockElement = (node) => {
+  if (!isHtmlElement(node))
+    return false;
+  const element = node;
+  return !isHtmlInlineElement(element);
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/isLastNonEmptyTextOfInlineFormattingContext.ts
+var isLastNonEmptyTextOfInlineFormattingContext = (initialText) => {
+  let currentNode = initialText;
+  while (true) {
+    if (currentNode.nextSibling) {
+      currentNode = currentNode.nextSibling;
+    } else {
+      currentNode = currentNode.parentElement;
+      if (currentNode && isHtmlBlockElement(currentNode)) {
+        return true;
+      }
+      currentNode = (currentNode == null ? void 0 : currentNode.nextSibling) || null;
+    }
+    if (!currentNode) {
+      return true;
+    }
+    if (isHtmlBlockElement(currentNode)) {
+      return true;
+    }
+    if ((currentNode.textContent || "").length > 0) {
+      return false;
+    }
+  }
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/stateTransforms.ts
+var upsertInlineFormattingContext = (state) => {
+  if (state.inlineFormattingContext) {
+    state.inlineFormattingContext.atStart = false;
+  } else {
+    state.inlineFormattingContext = {
+      atStart: true,
+      lastHasTrailingWhiteSpace: false
+    };
+  }
+};
+var endInlineFormattingContext = (state) => {
+  state.inlineFormattingContext = null;
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/collapseWhiteSpaceText.ts
+var collapseWhiteSpaceText = (text, state) => {
+  const textContent = text.textContent || "";
+  const isWhiteSpaceOnly = textContent.trim() === "";
+  if (state.inlineFormattingContext || !isWhiteSpaceOnly) {
+    upsertInlineFormattingContext(state);
+  }
+  const { whiteSpaceRule } = state;
+  const trimStart = (() => {
+    if (whiteSpaceRule !== "normal")
+      return "collapse";
+    if (!state.inlineFormattingContext || state.inlineFormattingContext.atStart || state.inlineFormattingContext.lastHasTrailingWhiteSpace)
+      return "all";
+    return "collapse";
+  })();
+  const trimEnd = (() => {
+    if (whiteSpaceRule === "normal")
+      return "collapse";
+    if (isLastNonEmptyTextOfInlineFormattingContext(text))
+      return "single-newline";
+    return "collapse";
+  })();
+  const shouldCollapseWhiteSpace = {
+    normal: true,
+    pre: false,
+    "pre-line": true
+  }[whiteSpaceRule];
+  const whiteSpaceIncludesNewlines = whiteSpaceRule !== "pre-line";
+  const collapsedTextContent = collapseString(textContent || "", {
+    trimStart,
+    trimEnd,
+    shouldCollapseWhiteSpace,
+    whiteSpaceIncludesNewlines
+  });
+  if (state.inlineFormattingContext && shouldCollapseWhiteSpace) {
+    state.inlineFormattingContext.lastHasTrailingWhiteSpace = collapsedTextContent.endsWith(" ");
+  }
+  text.textContent = collapsedTextContent;
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/collapseWhiteSpaceNode.ts
+var collapseWhiteSpaceNode = (node, state) => {
+  if (isHtmlElement(node)) {
+    collapseWhiteSpaceElement(node, state);
+    return;
+  }
+  if (isHtmlText(node)) {
+    collapseWhiteSpaceText(node, state);
+    return;
+  }
+  collapseWhiteSpaceChildren(node, state);
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/collapseWhiteSpaceChildren.ts
+var collapseWhiteSpaceChildren = (node, state) => {
+  const childNodes = Array.from(node.childNodes);
+  for (const childNode of childNodes) {
+    collapseWhiteSpaceNode(childNode, state);
+  }
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/inferWhiteSpaceRule.ts
+var inferWhiteSpaceRule = (element) => {
+  const whiteSpaceProperty = element.style.whiteSpace;
+  switch (whiteSpaceProperty) {
+    case "normal":
+    case "nowrap": {
+      return "normal";
+    }
+    case "pre":
+    case "pre-wrap":
+    case "break-spaces": {
+      return "pre";
+    }
+    case "pre-line": {
+      return "pre-line";
+    }
+  }
+  if (element.tagName === "PRE") {
+    return "pre";
+  }
+  if (whiteSpaceProperty === "initial") {
+    return "normal";
+  }
+  return null;
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/collapseWhiteSpaceElement.ts
+var collapseWhiteSpaceElement = (element, state) => {
+  const isInlineElement = isHtmlInlineElement(element);
+  const previousWhiteSpaceRule = state.whiteSpaceRule;
+  const inferredWhiteSpaceRule = inferWhiteSpaceRule(element);
+  if (inferredWhiteSpaceRule) {
+    state.whiteSpaceRule = inferredWhiteSpaceRule;
+  }
+  if (!isInlineElement) {
+    endInlineFormattingContext(state);
+  }
+  collapseWhiteSpaceChildren(element, state);
+  if (!isInlineElement) {
+    endInlineFormattingContext(state);
+  }
+  state.whiteSpaceRule = previousWhiteSpaceRule;
+};
+
+// src/plugins/html-deserializer/utils/collapse-white-space/collapseWhiteSpace.ts
+var collapseWhiteSpace = (element) => {
+  const clonedElement = element.cloneNode(true);
+  const state = {
+    inlineFormattingContext: null,
+    whiteSpaceRule: "normal"
+  };
+  collapseWhiteSpaceElement(clonedElement, state);
+  return clonedElement;
+};
+
+// src/plugins/html-deserializer/utils/deserializeHtmlNodeChildren.ts
+var deserializeHtmlNodeChildren = (editor, node) => Array.from(node.childNodes).flatMap(
+  deserializeHtmlNode(editor)
+);
+
+// src/plugins/html-deserializer/utils/htmlBodyToFragment.ts
+var htmlBodyToFragment = (editor, element) => {
+  if (element.nodeName === "BODY") {
+    return slateHyperscript.jsx(
+      "fragment",
+      {},
+      deserializeHtmlNodeChildren(editor, element)
+    );
+  }
+};
+
+// src/plugins/html-deserializer/utils/htmlBrToNewLine.ts
+var htmlBrToNewLine = (node) => {
+  if (node.nodeName === "BR") {
+    return "\n";
+  }
+};
+var pluginDeserializeHtml = (editor, plugin, {
+  element: el,
+  deserializeLeaf
+}) => {
+  var _a;
+  const {
+    deserializeHtml: deserializeHtml2,
+    isElement: isElementRoot,
+    isLeaf: isLeafRoot,
+    type
+  } = plugin;
+  if (!deserializeHtml2)
+    return;
+  const {
+    attributeNames,
+    query,
+    isLeaf: isLeafRule,
+    isElement: isElementRule,
+    rules
+  } = deserializeHtml2;
+  let { getNode } = deserializeHtml2;
+  const isElement4 = isElementRule || isElementRoot;
+  const isLeaf = isLeafRule || isLeafRoot;
+  if (!deserializeLeaf && !isElement4) {
+    return;
+  }
+  if (deserializeLeaf && !isLeaf) {
+    return;
+  }
+  if (rules) {
+    const isValid = rules.some(
+      ({ validNodeName = "*", validStyle, validClassName, validAttribute }) => {
+        var _a2;
+        if (validNodeName) {
+          const validNodeNames = castArray.default(validNodeName);
+          if (validNodeNames.length > 0 && !validNodeNames.includes(el.nodeName) && validNodeName !== "*")
+            return false;
+        }
+        if (validClassName && !el.classList.contains(validClassName))
+          return false;
+        if (validStyle) {
+          for (const [key, value] of Object.entries(validStyle)) {
+            const values2 = castArray.default(value);
+            if (!values2.includes(el.style[key]) && value !== "*")
+              return;
+            if (value === "*" && !el.style[key])
+              return;
+            const defaultNodeValue = (_a2 = plugin.inject.props) == null ? void 0 : _a2.defaultNodeValue;
+            if (defaultNodeValue && defaultNodeValue === el.style[key]) {
+              return false;
+            }
+          }
+        }
+        if (validAttribute) {
+          if (typeof validAttribute === "string") {
+            if (!el.getAttributeNames().includes(validAttribute))
+              return false;
+          } else {
+            for (const [attributeName, attributeValue] of Object.entries(
+              validAttribute
+            )) {
+              const attributeValues = castArray.default(attributeValue);
+              const elAttribute = el.getAttribute(attributeName);
+              if (!index$3.isDefined(elAttribute) || !attributeValues.includes(elAttribute))
+                return false;
+            }
+          }
+        }
+        return true;
+      }
+    );
+    if (!isValid)
+      return;
+  }
+  if (query && !query(el)) {
+    return;
+  }
+  if (!getNode) {
+    if (isElement4) {
+      getNode = () => ({ type });
+    } else if (isLeaf) {
+      getNode = () => ({ [type]: true });
+    } else {
+      return;
+    }
+  }
+  let node = (_a = getNode(el, {})) != null ? _a : {};
+  if (Object.keys(node).length === 0)
+    return;
+  const injectedPlugins = getInjectedPlugins(editor, plugin);
+  injectedPlugins.forEach((injectedPlugin) => {
+    var _a2, _b;
+    const res = (_b = (_a2 = injectedPlugin.deserializeHtml) == null ? void 0 : _a2.getNode) == null ? void 0 : _b.call(_a2, el, node);
+    if (res) {
+      node = __spreadValues(__spreadValues({}, node), res);
+    }
+  });
+  if (attributeNames) {
+    const elementAttributes = {};
+    const elementAttributeNames = el.getAttributeNames();
+    for (const elementAttributeName of elementAttributeNames) {
+      if (attributeNames.includes(elementAttributeName)) {
+        elementAttributes[elementAttributeName] = el.getAttribute(elementAttributeName);
+      }
+    }
+    if (Object.keys(elementAttributes).length > 0) {
+      node.attributes = elementAttributes;
+    }
+  }
+  return __spreadProps(__spreadValues({}, deserializeHtml2), { node });
+};
+
+// src/plugins/html-deserializer/utils/pipeDeserializeHtmlElement.ts
+var pipeDeserializeHtmlElement = (editor, element) => {
+  let result;
+  [...editor.plugins].reverse().some((plugin) => {
+    result = pluginDeserializeHtml(editor, plugin, { element });
+    return !!result;
+  });
+  return result;
+};
+
+// src/plugins/html-deserializer/utils/htmlElementToElement.ts
+var htmlElementToElement = (editor, element) => {
+  var _a;
+  const deserialized = pipeDeserializeHtmlElement(editor, element);
+  if (deserialized) {
+    const { node, withoutChildren } = deserialized;
+    let descendants = (_a = node.children) != null ? _a : deserializeHtmlNodeChildren(editor, element);
+    if (descendants.length === 0 || withoutChildren) {
+      descendants = [{ text: "" }];
+    }
+    return slateHyperscript.jsx("element", node, descendants);
+  }
+};
+
+// src/plugins/html-deserializer/utils/pipeDeserializeHtmlLeaf.ts
+var pipeDeserializeHtmlLeaf = (editor, element) => {
+  let node = {};
+  [...editor.plugins].reverse().forEach((plugin) => {
+    const deserialized = pluginDeserializeHtml(editor, plugin, {
+      element,
+      deserializeLeaf: true
+    });
+    if (!deserialized)
+      return;
+    node = __spreadValues(__spreadValues({}, node), deserialized.node);
+  });
+  return node;
+};
+
+// src/plugins/html-deserializer/utils/htmlElementToLeaf.ts
+var htmlElementToLeaf = (editor, element) => {
+  const node = pipeDeserializeHtmlLeaf(editor, element);
+  return deserializeHtmlNodeChildren(editor, element).reduce(
+    (arr, child) => {
+      if (!child)
+        return arr;
+      if (index$6.isElement(child)) {
+        if (Object.keys(node).length > 0) {
+          mergeDeepToNodes({
+            node: child,
+            source: node,
+            query: {
+              filter: ([n]) => index$6.isText(n)
+            }
+          });
+        }
+        arr.push(child);
+      } else {
+        const attributes = __spreadValues({}, node);
+        if (index$6.isText(child) && child.text) {
+          Object.keys(attributes).forEach((key) => {
+            if (attributes[key] && child[key]) {
+              attributes[key] = child[key];
+            }
+          });
+        }
+        arr.push(slateHyperscript.jsx("text", attributes, child));
+      }
+      return arr;
+    },
+    []
+  );
+};
+
+// src/plugins/html-deserializer/utils/htmlTextNodeToString.ts
+var htmlTextNodeToString = (node) => {
+  if (isHtmlText(node)) {
+    return node.textContent || "";
+  }
+};
+
+// src/plugins/html-deserializer/utils/deserializeHtmlNode.ts
+var deserializeHtmlNode = (editor) => (node) => {
+  const textNode = htmlTextNodeToString(node);
+  if (textNode)
+    return textNode;
+  if (!isHtmlElement(node))
+    return null;
+  const breakLine = htmlBrToNewLine(node);
+  if (breakLine)
+    return breakLine;
+  const fragment = htmlBodyToFragment(editor, node);
+  if (fragment)
+    return fragment;
+  const element = htmlElementToElement(editor, node);
+  if (element)
+    return element;
+  return htmlElementToLeaf(editor, node);
+};
+
+// src/plugins/html-deserializer/utils/deserializeHtmlElement.ts
+var deserializeHtmlElement = (editor, element) => {
+  return deserializeHtmlNode(editor)(element);
+};
+
+// src/plugins/html-deserializer/utils/htmlStringToDOMNode.ts
+var htmlStringToDOMNode = (rawHtml) => {
+  const node = document.createElement("body");
+  node.innerHTML = rawHtml;
+  return node;
+};
+
+// src/plugins/html-deserializer/utils/deserializeHtml.ts
+var deserializeHtml = (editor, {
+  element,
+  collapseWhiteSpace: shouldCollapseWhiteSpace = true
+}) => {
+  if (typeof element === "string") {
+    element = htmlStringToDOMNode(element);
+  }
+  if (shouldCollapseWhiteSpace) {
+    element = collapseWhiteSpace(element);
+  }
+  const fragment = deserializeHtmlElement(editor, element);
+  return normalizeDescendantsToDocumentFragment(editor, {
+    descendants: fragment
+  });
+};
+
+// src/plugins/html-deserializer/utils/parseHtmlDocument.ts
+var parseHtmlDocument = (html) => {
+  return new DOMParser().parseFromString(html, "text/html");
+};
+
+// src/plugins/html-deserializer/createDeserializeHtmlPlugin.ts
+var KEY_DESERIALIZE_HTML = "deserializeHtml";
+var createDeserializeHtmlPlugin = createPluginFactory({
+  key: KEY_DESERIALIZE_HTML,
+  then: (editor) => ({
+    editor: {
+      insertData: {
+        format: "text/html",
+        getFragment: ({ data }) => {
+          const document2 = parseHtmlDocument(data);
+          return deserializeHtml(editor, {
+            element: document2.body
+          });
+        }
+      }
+    }
+  })
+});
+var mergeDeepPlugins = (editor, _plugin) => {
+  const plugin = __spreadValues({}, _plugin);
+  const { then } = plugin;
+  if (then) {
+    delete plugin.then;
+    const { plugins: pluginPlugins } = plugin;
+    const pluginThen = mergeDeepPlugins(
+      editor,
+      defaultsDeep.default(then(editor, plugin), plugin)
+    );
+    if (pluginPlugins && pluginThen.plugins) {
+      const merged = merge.default(
+        keyBy.default(pluginPlugins, "key"),
+        keyBy.default(pluginThen.plugins, "key")
+      );
+      pluginThen.plugins = values.default(merged);
+    }
+    return pluginThen;
+  }
+  return plugin;
+};
+
+// src/utils/setDefaultPlugin.ts
+var setDefaultPlugin = (plugin) => {
+  if (plugin.type === void 0)
+    plugin.type = plugin.key;
+  if (!plugin.options)
+    plugin.options = {};
+  if (!plugin.inject)
+    plugin.inject = {};
+  if (!plugin.editor)
+    plugin.editor = {};
+  return plugin;
+};
+
+// src/utils/flattenDeepPlugins.ts
+var flattenDeepPlugins = (editor, plugins) => {
+  if (!plugins)
+    return;
+  plugins.forEach((plugin) => {
+    let p = setDefaultPlugin(plugin);
+    p = mergeDeepPlugins(editor, p);
+    if (p.enabled === false)
+      return;
+    if (editor.pluginsByKey[p.key]) {
+      const index = editor.plugins.indexOf(editor.pluginsByKey[p.key]);
+      const mergedPlugin = defaultsDeep.default(p, editor.pluginsByKey[p.key]);
+      if (index >= 0) {
+        editor.plugins[index] = mergedPlugin;
+      }
+      editor.pluginsByKey[p.key] = mergedPlugin;
+    } else {
+      editor.plugins.push(p);
+      editor.pluginsByKey[p.key] = p;
+    }
+    flattenDeepPlugins(editor, p.plugins);
+  });
+};
+
+// src/utils/setPlatePlugins.ts
+var setPlatePlugins = (editor, {
+  disableCorePlugins,
+  plugins: _plugins = [],
+  maxLength
+}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
+  let plugins = [];
+  if (disableCorePlugins !== true) {
+    const dcp = disableCorePlugins;
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.react)) {
+      plugins.push((_b = (_a = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _a.react) != null ? _b : createReactPlugin());
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.history)) {
+      plugins.push(
+        (_d = (_c = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _c.history) != null ? _d : createHistoryPlugin()
+      );
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.nodeFactory)) {
+      plugins.push(
+        (_f = (_e = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _e[KEY_NODE_FACTORY]) != null ? _f : createNodeFactoryPlugin()
+      );
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.eventEditor)) {
+      plugins.push(
+        (_h = (_g = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _g[KEY_EVENT_EDITOR]) != null ? _h : createEventEditorPlugin()
+      );
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.inlineVoid)) {
+      plugins.push(
+        (_j = (_i = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _i[KEY_INLINE_VOID]) != null ? _j : createInlineVoidPlugin()
+      );
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.insertData)) {
+      plugins.push(
+        (_l = (_k = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _k[KEY_INSERT_DATA]) != null ? _l : createInsertDataPlugin()
+      );
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.selection)) {
+      plugins.push(
+        (_n = (_m = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _m[KEY_PREV_SELECTION]) != null ? _n : createPrevSelectionPlugin()
+      );
+    }
+    if ((typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.length)) && index$3.isDefined(maxLength)) {
+      plugins.push(
+        (_p = (_o = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _o[KEY_LENGTH]) != null ? _p : createLengthPlugin({
+          options: {
+            maxLength
+          }
+        })
+      );
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.deserializeHtml)) {
+      plugins.push(
+        (_r = (_q = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _q[KEY_DESERIALIZE_HTML]) != null ? _r : createDeserializeHtmlPlugin()
+      );
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.deserializeAst)) {
+      plugins.push(
+        (_t = (_s = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _s[KEY_DESERIALIZE_AST]) != null ? _t : createDeserializeAstPlugin()
+      );
+    }
+    if (typeof dcp !== "object" || !(dcp == null ? void 0 : dcp.editorProtocol)) {
+      plugins.push(
+        (_v = (_u = editor == null ? void 0 : editor.pluginsByKey) == null ? void 0 : _u[KEY_EDITOR_PROTOCOL]) != null ? _v : createEditorProtocolPlugin()
+      );
+    }
+  }
+  plugins = [...plugins, ..._plugins];
+  editor.plugins = [];
+  editor.pluginsByKey = {};
+  flattenDeepPlugins(editor, plugins);
+  editor.plugins.forEach((plugin) => {
+    if (plugin.overrideByKey) {
+      const newPlugins = editor.plugins.map((p) => {
+        return overridePluginsByKey(p, plugin.overrideByKey);
+      });
+      editor.plugins = [];
+      editor.pluginsByKey = {};
+      flattenDeepPlugins(editor, newPlugins);
+    }
+  });
+};
+
+// src/plugins/withPlate.ts
+var shouldHaveBeenOverridden = (fnName) => () => {
+  console.warn(
+    `editor.${fnName} should have been overriden but was not. Please report this issue here: https://github.com/udecode/plate/issues`
+  );
+};
+var withPlate = (e, {
+  id,
+  plugins = [],
+  disableCorePlugins,
+  maxLength
+} = {}) => {
+  let editor = e;
+  editor.id = id != null ? id : editor.id;
+  editor.prevSelection = null;
+  editor.isFallback = false;
+  editor.currentKeyboardEvent = null;
+  editor.reset = () => resetEditor(editor);
+  editor.redecorate = () => shouldHaveBeenOverridden("redecorate");
+  editor.plate = {
+    get set() {
+      return null;
+    }
+  };
+  if (!editor.key) {
+    editor.key = Math.random();
+  }
+  setPlatePlugins(editor, {
+    plugins,
+    maxLength,
+    disableCorePlugins
+  });
+  editor.plugins.forEach((plugin) => {
+    if (plugin.withOverrides) {
+      editor = plugin.withOverrides(editor, plugin);
+    }
+  });
+  return editor;
+};
+var createPlugins = (plugins, {
+  components,
+  overrideByKey
+} = {}) => {
+  let allOverrideByKey = {};
+  if (overrideByKey) {
+    allOverrideByKey = cloneDeep.default(overrideByKey);
+  }
+  if (components) {
+    Object.keys(components).forEach((key) => {
+      if (!allOverrideByKey[key])
+        allOverrideByKey[key] = {};
+      allOverrideByKey[key].component = components[key];
+    });
+  }
+  if (Object.keys(allOverrideByKey).length > 0) {
+    return plugins.map((plugin) => {
+      return overridePluginsByKey(plugin, allOverrideByKey);
+    });
+  }
+  return plugins;
+};
+
+// src/utils/createPlateEditor.ts
+var createPlateEditor = (_a = {}) => {
+  var _b = _a, {
+    editor = index$6.createTEditor(),
+    plugins = [],
+    components,
+    overrideByKey,
+    normalizeInitialValue: shouldNormalizeInitialValue
+  } = _b, withPlateOptions = __objRest(_b, [
+    "editor",
+    "plugins",
+    "components",
+    "overrideByKey",
+    "normalizeInitialValue"
+  ]);
+  plugins = createPlugins(plugins, {
+    components,
+    overrideByKey
+  });
+  const e = withPlate(editor, __spreadValues({
+    plugins
+  }, withPlateOptions));
+  if (shouldNormalizeInitialValue) {
+    index$6.normalizeEditor(e, { force: true });
+  }
+  return e;
+};
+
+// src/utils/createPlateFallbackEditor.ts
+var createPlateFallbackEditor = (options = {}) => {
+  const editor = createPlateEditor(options);
+  editor.isFallback = true;
+  editor.apply = () => {
+    throw new Error(
+      "Cannot apply operations on the fallback editor. The fallback editor is used when a hook that depends on the Plate store was unable to locate a valid store. If you are using PlateController, use `useEditorMounted(id?: PlateId)` or `!editor.isFallback` to ensure that a valid Plate store is available before attempting to call operations on the editor."
+    );
+  };
+  return editor;
+};
+
+// src/utils/getPluginInjectProps.ts
+var getPluginInjectProps = (editor, key) => {
+  var _a, _b;
+  return (_b = (_a = getPlugin(editor, key).inject) == null ? void 0 : _a.props) != null ? _b : {};
+};
+
+// src/utils/getPluginOptions.ts
+var getPluginOptions = (editor, key) => {
+  var _a;
+  return (_a = getPlugin(editor, key).options) != null ? _a : {};
+};
+
+// src/utils/getPluginTypes.ts
+var getPluginTypes = (editor, keys) => keys.map((key) => getPluginType(editor, key));
+
+// src/utils/misc/getSlateClass.ts
+var getSlateClass = (type) => `slate-${type}`;
+
+// src/utils/getRenderNodeProps.ts
+var getRenderNodeProps = ({
+  attributes,
+  nodeProps,
+  props,
+  type
+}) => {
+  var _a;
+  let newProps = {};
+  if (props) {
+    newProps = (_a = typeof props === "function" ? props(nodeProps) : props) != null ? _a : {};
+  }
+  if (!newProps.nodeProps && attributes) {
+    newProps.nodeProps = attributes;
+  }
+  nodeProps = __spreadValues(__spreadValues({}, nodeProps), newProps);
+  if (nodeProps.nodeProps) {
+    Object.keys(nodeProps.nodeProps).forEach((key) => {
+      var _a2, _b;
+      if (((_a2 = nodeProps.nodeProps) == null ? void 0 : _a2[key]) === void 0) {
+        (_b = nodeProps.nodeProps) == null ? true : delete _b[key];
+      }
+    });
+  }
+  const { className } = nodeProps;
+  return __spreadProps(__spreadValues({}, nodeProps), { className: clsx_m.clsx(getSlateClass(type), className) });
+};
+var HOTKEYS = {
+  bold: "mod+b",
+  compose: ["down", "left", "right", "up", "backspace", "enter"],
+  deleteBackward: "shift?+backspace",
+  deleteForward: "shift?+delete",
+  extendBackward: "shift+left",
+  extendForward: "shift+right",
+  insertSoftBreak: "shift+enter",
+  italic: "mod+i",
+  moveBackward: "left",
+  moveForward: "right",
+  moveWordBackward: "ctrl+left",
+  moveWordForward: "ctrl+right",
+  splitBlock: "enter",
+  tab: "tab",
+  untab: "shift+tab",
+  undo: "mod+z"
+};
+var APPLE_HOTKEYS = {
+  deleteBackward: ["ctrl+backspace", "ctrl+h"],
+  deleteForward: ["ctrl+delete", "ctrl+d"],
+  deleteLineBackward: "cmd+shift?+backspace",
+  deleteLineForward: ["cmd+shift?+delete", "ctrl+k"],
+  deleteWordBackward: "opt+shift?+backspace",
+  deleteWordForward: "opt+shift?+delete",
+  extendLineBackward: "opt+shift+up",
+  extendLineForward: "opt+shift+down",
+  moveLineBackward: "opt+up",
+  moveLineForward: "opt+down",
+  moveWordBackward: "opt+left",
+  moveWordForward: "opt+right",
+  redo: "cmd+shift+z",
+  transposeCharacter: "ctrl+t"
+};
+var WINDOWS_HOTKEYS = {
+  deleteWordBackward: "ctrl+shift?+backspace",
+  deleteWordForward: "ctrl+shift?+delete",
+  redo: ["ctrl+y", "ctrl+shift+z"]
+};
+var create = (key) => {
+  const generic = HOTKEYS[key];
+  const apple = APPLE_HOTKEYS[key];
+  const windows = WINDOWS_HOTKEYS[key];
+  const isGeneric = generic && index$2.isKeyHotkey(generic);
+  const isApple = apple && index$2.isKeyHotkey(apple);
+  const isWindows = windows && index$2.isKeyHotkey(windows);
+  return (event) => {
+    if (isGeneric && isGeneric(event))
+      return true;
+    if (index$3.IS_APPLE && isApple && isApple(event))
+      return true;
+    if (!index$3.IS_APPLE && isWindows && isWindows(event))
+      return true;
+    return false;
+  };
+};
+var createComposing = (key) => (editor, event, {
+  composing
+} = {}) => {
+  if (!create(key)(event))
+    return false;
+  if (!!composing !== index$4.isComposing(editor))
+    return false;
+  return true;
+};
+({
+  isBold: create("bold"),
+  isCompose: create("compose"),
+  isMoveBackward: create("moveBackward"),
+  isMoveForward: create("moveForward"),
+  isDeleteBackward: create("deleteBackward"),
+  isDeleteForward: create("deleteForward"),
+  isDeleteLineBackward: create("deleteLineBackward"),
+  isDeleteLineForward: create("deleteLineForward"),
+  isDeleteWordBackward: create("deleteWordBackward"),
+  isDeleteWordForward: create("deleteWordForward"),
+  isExtendBackward: create("extendBackward"),
+  isExtendForward: create("extendForward"),
+  isExtendLineBackward: create("extendLineBackward"),
+  isExtendLineForward: create("extendLineForward"),
+  isItalic: create("italic"),
+  isMoveLineBackward: create("moveLineBackward"),
+  isMoveLineForward: create("moveLineForward"),
+  isMoveWordBackward: create("moveWordBackward"),
+  isMoveWordForward: create("moveWordForward"),
+  isRedo: create("redo"),
+  isSoftBreak: create("insertSoftBreak"),
+  isSplitBlock: create("splitBlock"),
+  isTab: createComposing("tab"),
+  isTransposeCharacter: create("transposeCharacter"),
+  isUndo: create("undo"),
+  isUntab: createComposing("untab")
+});
+var mergeDeepToNodes = (options) => {
+  applyDeepToNodes(__spreadProps(__spreadValues({}, options), { apply: merge.default }));
+};
+
+// src/utils/mockPlugin.ts
+var mockPlugin = (plugin) => __spreadValues({
+  key: "",
+  type: "",
+  editor: {},
+  inject: {},
+  options: {}
+}, plugin);
+
+// src/utils/pipeDecorate.ts
+var pipeDecorate = (editor, decorateProp) => {
+  const decorates = editor.plugins.flatMap(
+    (plugin) => {
+      var _a, _b;
+      return (_b = (_a = plugin.decorate) == null ? void 0 : _a.call(plugin, editor, plugin)) != null ? _b : [];
+    }
+  );
+  if (decorateProp) {
+    decorates.push(decorateProp);
+  }
+  if (decorates.length === 0)
+    return;
+  return (entry) => {
+    let ranges = [];
+    const addRanges = (newRanges) => {
+      if (newRanges == null ? void 0 : newRanges.length)
+        ranges = [...ranges, ...newRanges];
+    };
+    decorates.forEach((decorate) => {
+      addRanges(decorate(entry));
+    });
+    return ranges;
+  };
+};
+
+// src/utils/pipeHandler.ts
+var convertDomEventToSyntheticEvent = (domEvent) => {
+  let propagationStopped = false;
+  return __spreadProps(__spreadValues({}, domEvent), {
+    nativeEvent: domEvent,
+    currentTarget: domEvent.currentTarget,
+    target: domEvent.target,
+    bubbles: domEvent.bubbles,
+    cancelable: domEvent.cancelable,
+    defaultPrevented: domEvent.defaultPrevented,
+    eventPhase: domEvent.eventPhase,
+    isTrusted: domEvent.isTrusted,
+    timeStamp: domEvent.timeStamp,
+    type: domEvent.type,
+    isDefaultPrevented: () => domEvent.defaultPrevented,
+    isPropagationStopped: () => propagationStopped,
+    persist: () => {
+      throw new Error(
+        "persist is not implemented for synthetic events created using convertDomEventToSyntheticEvent"
+      );
+    },
+    preventDefault: () => domEvent.preventDefault(),
+    stopPropagation: () => {
+      propagationStopped = true;
+      domEvent.stopPropagation();
+    }
+  });
+};
+var isEventHandled = (event, handler) => {
+  if (!handler) {
+    return false;
+  }
+  const shouldTreatEventAsHandled = handler(event);
+  if (shouldTreatEventAsHandled != null) {
+    return shouldTreatEventAsHandled;
+  }
+  return event.isPropagationStopped();
+};
+var pipeHandler = (editor, {
+  editableProps,
+  handlerKey
+}) => {
+  let pluginsHandlers = [];
+  pluginsHandlers = editor.plugins.flatMap(
+    (plugin) => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = plugin.handlers) == null ? void 0 : _a[handlerKey]) == null ? void 0 : _b.call(_a, editor, plugin)) != null ? _c : [];
+    }
+  );
+  const propsHandler = editableProps == null ? void 0 : editableProps[handlerKey];
+  if (pluginsHandlers.length === 0 && !propsHandler)
+    return;
+  return (event) => {
+    const isDomEvent = event instanceof Event;
+    const handledEvent = isDomEvent ? convertDomEventToSyntheticEvent(event) : event;
+    const eventIsHandled = pluginsHandlers.some(
+      (handler) => isEventHandled(handledEvent, handler)
+    );
+    if (eventIsHandled)
+      return true;
+    return isEventHandled(handledEvent, propsHandler);
+  };
+};
+var pluginInjectProps = (editor, { key, inject: { props } }, nodeProps) => {
+  var _a, _b, _c, _d;
+  const { element, text, className, style } = nodeProps;
+  const node = element != null ? element : text;
+  if (!node)
+    return;
+  if (!props)
+    return;
+  const {
+    nodeKey = key,
+    styleKey = nodeKey,
+    validTypes,
+    classNames,
+    transformClassName,
+    transformNodeValue,
+    transformProps,
+    transformStyle,
+    validNodeValues,
+    defaultNodeValue,
+    query
+  } = props;
+  const queryResult = query == null ? void 0 : query(props, nodeProps);
+  if (!queryResult && validTypes && index$6.isElement(node) && node.type && !validTypes.includes(node.type)) {
+    return;
+  }
+  const nodeValue = node[nodeKey];
+  if (!queryResult && (!index$3.isDefined(nodeValue) || validNodeValues && !validNodeValues.includes(nodeValue) || nodeValue === defaultNodeValue)) {
+    return;
+  }
+  const transformOptions = __spreadProps(__spreadValues({}, nodeProps), { nodeValue });
+  const value = (_a = transformNodeValue == null ? void 0 : transformNodeValue(transformOptions)) != null ? _a : nodeValue;
+  transformOptions.value = value;
+  let res = {};
+  if (element) {
+    res.className = clsx_m.clsx(className, `slate-${nodeKey}-${nodeValue}`);
+  }
+  if ((classNames == null ? void 0 : classNames[nodeValue]) || transformClassName) {
+    res.className = (_b = transformClassName == null ? void 0 : transformClassName(transformOptions)) != null ? _b : clsx_m.clsx(className, classNames == null ? void 0 : classNames[value]);
+  }
+  if (styleKey) {
+    res.style = (_c = transformStyle == null ? void 0 : transformStyle(transformOptions)) != null ? _c : __spreadProps(__spreadValues({}, style), {
+      [styleKey]: value
+    });
+  }
+  if (transformProps) {
+    res = (_d = transformProps(transformOptions, res)) != null ? _d : res;
+  }
+  return res;
+};
+
+// src/utils/pipeInjectProps.tsx
+var pipeInjectProps = (editor, nodeProps) => {
+  editor.plugins.forEach((plugin) => {
+    if (plugin.inject.props) {
+      const props = pluginInjectProps(editor, plugin, nodeProps);
+      if (props) {
+        nodeProps = __spreadValues(__spreadValues({}, nodeProps), props);
+      }
+    }
+  });
+  return __spreadProps(__spreadValues({}, nodeProps), { editor });
+};
+
+// src/utils/pipeOnChange.ts
+var pipeOnChange = (editor) => {
+  const onChanges = editor.plugins.flatMap(
+    (plugin) => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = plugin.handlers) == null ? void 0 : _a.onChange) == null ? void 0 : _b.call(_a, editor, plugin)) != null ? _c : [];
+    }
+  );
+  return (nodes) => {
+    return onChanges.some((handler) => {
+      if (!handler) {
+        return false;
+      }
+      const shouldTreatEventAsHandled = handler(nodes);
+      if (shouldTreatEventAsHandled != null) {
+        return shouldTreatEventAsHandled;
+      }
+      return false;
+    });
+  };
+};
+var pluginRenderElement = (editor, { key, type, component: _component, props }) => function render(nodeProps) {
+  const { element, children: _children } = nodeProps;
+  if (element.type === type) {
+    const Element = _component != null ? _component : slateReact.DefaultElement;
+    const injectAboveComponents = editor.plugins.flatMap(
+      (o) => {
+        var _a, _b;
+        return (_b = (_a = o.inject) == null ? void 0 : _a.aboveComponent) != null ? _b : [];
+      }
+    );
+    const injectBelowComponents = editor.plugins.flatMap(
+      (o) => {
+        var _a, _b;
+        return (_b = (_a = o.inject) == null ? void 0 : _a.belowComponent) != null ? _b : [];
+      }
+    );
+    nodeProps = getRenderNodeProps({
+      attributes: element.attributes,
+      nodeProps,
+      props,
+      type
+    });
+    let children = _children;
+    injectBelowComponents.forEach((withHOC2) => {
+      const hoc = withHOC2(__spreadProps(__spreadValues({}, nodeProps), { key }));
+      if (hoc) {
+        children = hoc(__spreadProps(__spreadValues({}, nodeProps), { children }));
+      }
+    });
+    let component = /* @__PURE__ */ React__default.default.createElement(Element, __spreadValues({}, nodeProps), children);
+    injectAboveComponents.forEach((withHOC2) => {
+      const hoc = withHOC2(__spreadProps(__spreadValues({}, nodeProps), { key }));
+      if (hoc) {
+        component = hoc(__spreadProps(__spreadValues({}, nodeProps), { children: component }));
+      }
+    });
+    return /* @__PURE__ */ React__default.default.createElement(ElementProvider, { element, scope: key }, component);
+  }
+};
+
+// src/utils/pipeRenderElement.tsx
+var pipeRenderElement = (editor, renderElementProp) => {
+  const renderElements = [];
+  editor.plugins.forEach((plugin) => {
+    if (plugin.isElement) {
+      renderElements.push(pluginRenderElement(editor, plugin));
+    }
+  });
+  return function render(nodeProps) {
+    const props = pipeInjectProps(editor, nodeProps);
+    let element;
+    renderElements.some((renderElement) => {
+      element = renderElement(props);
+      return !!element;
+    });
+    if (element)
+      return element;
+    if (renderElementProp) {
+      return renderElementProp(props);
+    }
+    return /* @__PURE__ */ React__default.default.createElement(slateReact.DefaultElement, __spreadValues({}, props));
+  };
+};
+var pluginRenderLeaf = (editor, { key, type = key, component, props }) => function render(nodeProps) {
+  const { leaf, children } = nodeProps;
+  if (leaf[type]) {
+    const Leaf = component != null ? component : DefaultLeaf;
+    nodeProps = getRenderNodeProps({
+      attributes: leaf.attributes,
+      props,
+      nodeProps,
+      type
+    });
+    return /* @__PURE__ */ React__default.default.createElement(Leaf, __spreadValues({}, nodeProps), children);
+  }
+  return children;
+};
+
+// src/utils/pipeRenderLeaf.tsx
+var pipeRenderLeaf = (editor, renderLeafProp) => {
+  const renderLeafs = [];
+  editor.plugins.forEach((plugin) => {
+    if (plugin.isLeaf && plugin.key) {
+      renderLeafs.push(pluginRenderLeaf(editor, plugin));
+    }
+  });
+  return function render(nodeProps) {
+    const props = pipeInjectProps(editor, nodeProps);
+    renderLeafs.forEach((renderLeaf) => {
+      const newChildren = renderLeaf(props);
+      if (newChildren !== void 0) {
+        props.children = newChildren;
+      }
+    });
+    if (renderLeafProp) {
+      return renderLeafProp(props);
+    }
+    return /* @__PURE__ */ React__default.default.createElement(DefaultLeaf, __spreadValues({}, props));
+  };
+};
+var withHOC = (HOC, Component, hocProps, hocRef) => React__default.default.forwardRef((props, componentRef) => /* @__PURE__ */ React__default.default.createElement(HOC, __spreadProps(__spreadValues({}, hocProps), { ref: hocRef }), /* @__PURE__ */ React__default.default.createElement(Component, __spreadProps(__spreadValues({}, props), { ref: componentRef }))));
+var {
+  plateControllerStore,
+  usePlateControllerStore,
+  PlateControllerProvider: PlateController
+} = index.createAtomStore(
+  {
+    activeId: vanilla.atom(null),
+    primaryEditorIds: vanilla.atom([]),
+    editorStores: vanilla.atom({})
+  },
+  {
+    name: "plateController"
+  }
+);
+var usePlateControllerSelectors = () => usePlateControllerStore().get;
+var usePlateControllerActions = () => usePlateControllerStore().set;
+var usePlateControllerExists = () => !!usePlateControllerStore().store({ warnIfNoStore: false });
+var usePlateControllerEditorStore = (idProp) => {
+  const storeAtom = React__default.default.useMemo(
+    () => vanilla.atom((get) => {
+      const editorStores = get(plateControllerStore.atom.editorStores);
+      const forId = (id) => {
+        var _a;
+        if (!id)
+          return null;
+        return (_a = editorStores[id]) != null ? _a : null;
+      };
+      if (idProp)
+        return forId(idProp);
+      const lookupOrder = [
+        get(plateControllerStore.atom.activeId),
+        ...get(plateControllerStore.atom.primaryEditorIds)
+      ];
+      for (const id of lookupOrder) {
+        const store = forId(id);
+        if (store)
+          return store;
+      }
+      return null;
+    }),
+    [idProp]
+  );
+  return usePlateControllerSelectors().atom(storeAtom);
+};
+var createPlateStore = (_a = {}) => {
+  var _b = _a, {
+    decorate = null,
+    editor = createPlateFallbackEditor(),
+    id,
+    isMounted = false,
+    versionDecorate = 1,
+    versionEditor = 1,
+    versionSelection = 1,
+    onChange = null,
+    editorRef = null,
+    plugins = [],
+    rawPlugins = [],
+    readOnly = null,
+    primary = true,
+    renderElement = null,
+    renderLeaf = null,
+    value = null
+  } = _b, state = __objRest(_b, [
+    "decorate",
+    "editor",
+    "id",
+    "isMounted",
+    "versionDecorate",
+    "versionEditor",
+    "versionSelection",
+    "onChange",
+    "editorRef",
+    "plugins",
+    "rawPlugins",
+    "readOnly",
+    "primary",
+    "renderElement",
+    "renderLeaf",
+    "value"
+  ]);
+  return index.createAtomStore(
+    __spreadValues({
+      decorate,
+      editor,
+      id,
+      isMounted,
+      versionDecorate,
+      versionEditor,
+      versionSelection,
+      onChange,
+      editorRef,
+      plugins,
+      rawPlugins,
+      readOnly,
+      primary,
+      renderElement,
+      renderLeaf,
+      value
+    }, state),
+    {
+      name: "plate",
+      extend: (atoms) => ({
+        trackedEditor: vanilla.atom((get) => ({
+          editor: get(atoms.editor),
+          version: get(atoms.versionEditor)
+        })),
+        trackedSelection: vanilla.atom((get) => ({
+          selection: get(atoms.editor).selection,
+          version: get(atoms.versionSelection)
+        }))
+      })
+    }
+  );
+};
+var {
+  plateStore,
+  usePlateStore,
+  PlateProvider: PlateStoreProvider
+} = createPlateStore();
+var usePlateEditorStore = (id, { debugHookName = "usePlateEditorStore" } = {}) => {
+  var _a;
+  const localStore = (_a = usePlateStore(id).store({ warnIfNoStore: false })) != null ? _a : null;
+  const [localStoreExists] = React__default.default.useState(!!localStore);
+  const store = localStoreExists ? localStore : (
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    usePlateControllerEditorStore(id)
+  );
+  const plateControllerExists = usePlateControllerExists();
+  const fallbackStore = React__default.default.useMemo(() => vanilla.createStore(), []);
+  if (!store) {
+    if (plateControllerExists) {
+      return fallbackStore;
+    }
+    throw new Error(
+      `${debugHookName} must be used inside a Plate or PlateController`
+    );
+  }
+  return store;
+};
+var usePlateSelectors = (id, options) => {
+  const store = usePlateEditorStore(id, __spreadValues({
+    debugHookName: "usePlateSelectors"
+  }, options));
+  return usePlateStore({ store }).get;
+};
+var usePlateActions = (id, options) => {
+  const store = usePlateEditorStore(id, __spreadValues({
+    debugHookName: "usePlateActions"
+  }, options));
+  return usePlateStore({ store }).set;
+};
+var usePlateId = () => usePlateSelectors(void 0, { debugHookName: "usePlateId" }).id();
+var useIncrementVersion = (key, id, options = {}) => {
+  const previousVersionRef = React__default.default.useRef(1);
+  const set = usePlateActions(id, __spreadValues({
+    debugHookName: "useIncrementVersion"
+  }, options))[key]();
+  return React__default.default.useCallback(() => {
+    const nextVersion = previousVersionRef.current + 1;
+    set(nextVersion);
+    previousVersionRef.current = nextVersion;
+  }, [set]);
+};
+var useRedecorate = (id, options = {}) => {
+  const updateDecorate = useIncrementVersion("versionDecorate", id, __spreadValues({
+    debugHookName: "useRedecorate"
+  }, options));
+  return React__default.default.useCallback(() => {
+    updateDecorate();
+  }, [updateDecorate]);
+};
+
+// src/stores/plate/selectors/useEditorRef.ts
+var useEditorRef = (id, options = {}) => usePlateSelectors(id, __spreadValues({
+  debugHookName: "useEditorRef"
+}, options)).editor();
+
+// src/stores/plate/selectors/useEditorSelection.ts
+var useEditorSelection = (id, options = {}) => usePlateSelectors(id, __spreadValues({
+  debugHookName: "useEditorSelection"
+}, options)).trackedSelection().selection;
+var useEditorSelector = (selector, deps, _a = {}) => {
+  var _b = _a, {
+    id,
+    equalityFn = (a, b) => a === b
+  } = _b, storeOptions = __objRest(_b, [
+    "id",
+    "equalityFn"
+  ]);
+  const selectorAtom = React__default.default.useMemo(
+    () => utils.selectAtom(
+      plateStore.atom.trackedEditor,
+      ({ editor }, prev) => selector(editor, prev),
+      equalityFn
+    ),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    deps
+  );
+  return usePlateSelectors(id, __spreadValues({
+    debugHookName: "useEditorSelector"
+  }, storeOptions)).atom(selectorAtom);
+};
+
+// src/types/PlateStore.ts
+var EXPOSED_STORE_KEYS = [
+  "readOnly",
+  "plugins",
+  "onChange",
+  "decorate",
+  "renderElement",
+  "renderLeaf"
+];
+
+// src/components/EditorMethodsEffect.ts
+var EditorMethodsEffect = ({ id }) => {
+  const editor = useEditorRef(id);
+  const redecorate = useRedecorate(id);
+  const plateStore2 = usePlateStore(id);
+  const storeSetters = Object.fromEntries(
+    EXPOSED_STORE_KEYS.map((key) => [key, plateStore2.set[key]()])
+  );
+  const memorizedStoreSetters = React__default.default.useMemo(() => storeSetters, []);
+  React__default.default.useEffect(() => {
+    editor.redecorate = redecorate;
+    editor.plate = {
+      set: memorizedStoreSetters
+    };
+  }, [editor, redecorate, memorizedStoreSetters]);
+  return null;
+};
+function EditorRefPluginEffect({
+  id,
+  plugin
+}) {
+  var _a;
+  const editor = useEditorRef(id);
+  (_a = plugin.useHooks) == null ? void 0 : _a.call(plugin, editor, plugin);
+  return null;
+}
+function EditorRefEffect({ id }) {
+  const setIsMounted = usePlateActions(id).isMounted();
+  const plugins = usePlateSelectors(id).plugins();
+  const editorState = useEditorRef(id);
+  const editorRef = usePlateSelectors(id).editorRef();
+  React__default.default.useEffect(() => {
+    setIsMounted(true);
+    return () => {
+      setIsMounted(false);
+    };
+  }, [setIsMounted]);
+  React__default.default.useEffect(() => {
+    if (typeof editorRef === "function") {
+      editorRef(editorState);
+      return () => editorRef(null);
+    }
+    if (editorRef) {
+      editorRef.current = editorState;
+      return () => {
+        editorRef.current = null;
+      };
+    }
+  }, [editorRef, editorState]);
+  return /* @__PURE__ */ React__default.default.createElement(React__default.default.Fragment, null, plugins.map((plugin) => /* @__PURE__ */ React__default.default.createElement(EditorRefPluginEffect, { key: plugin.key, id, plugin })));
+}
+var EditorStateEffect = React__default.default.memo(({ id }) => {
+  const editorState = slateReact.useSlate();
+  const updateVersionEditor = useIncrementVersion("versionEditor", id);
+  React__default.default.useEffect(() => {
+    updateVersionEditor();
+  });
+  const updateVersionSelection = useIncrementVersion("versionSelection", id);
+  const prevSelectionRef = React__default.default.useRef(editorState.selection);
+  const sameSelection = isSelectionEqual(
+    prevSelectionRef.current,
+    editorState.selection
+  );
+  React__default.default.useEffect(() => {
+    if (!sameSelection) {
+      updateVersionSelection();
+    }
+    prevSelectionRef.current = editorState.selection;
+  }, [editorState.selection, sameSelection, updateVersionSelection]);
+  return null;
+});
+var isSelectionEqual = (a, b) => {
+  if (!a && !b)
+    return true;
+  if (!a || !b)
+    return false;
+  return slate.Range.equals(a, b);
+};
+
+// src/types/misc/dom-attributes.ts
+var DOM_HANDLERS = [
+  // Clipboard Events
+  "onCopy",
+  "onCopyCapture",
+  "onCut",
+  "onCutCapture",
+  "onPaste",
+  "onPasteCapture",
+  // Composition Events
+  "onCompositionEnd",
+  "onCompositionEndCapture",
+  "onCompositionStart",
+  "onCompositionStartCapture",
+  "onCompositionUpdate",
+  "onCompositionUpdateCapture",
+  // Focus Events
+  "onFocus",
+  "onFocusCapture",
+  "onBlur",
+  "onBlurCapture",
+  // Form Events
+  "onDOMBeforeInput",
+  "onBeforeInput",
+  "onBeforeInputCapture",
+  "onInput",
+  "onInputCapture",
+  "onReset",
+  "onResetCapture",
+  "onSubmit",
+  "onSubmitCapture",
+  "onInvalid",
+  "onInvalidCapture",
+  // Image Events
+  "onLoad",
+  "onLoadCapture",
+  // Keyboard Events
+  "onKeyDown",
+  "onKeyDownCapture",
+  "onKeyPress",
+  "onKeyPressCapture",
+  "onKeyUp",
+  "onKeyUpCapture",
+  // Media Events
+  "onAbort",
+  "onAbortCapture",
+  "onCanPlay",
+  "onCanPlayCapture",
+  "onCanPlayThrough",
+  "onCanPlayThroughCapture",
+  "onDurationChange",
+  "onDurationChangeCapture",
+  "onEmptied",
+  "onEmptiedCapture",
+  "onEncrypted",
+  "onEncryptedCapture",
+  "onEnded",
+  "onEndedCapture",
+  "onLoadedData",
+  "onLoadedDataCapture",
+  "onLoadedMetadata",
+  "onLoadedMetadataCapture",
+  "onLoadStart",
+  "onLoadStartCapture",
+  "onPause",
+  "onPauseCapture",
+  "onPlay",
+  "onPlayCapture",
+  "onPlaying",
+  "onPlayingCapture",
+  "onProgress",
+  "onProgressCapture",
+  "onRateChange",
+  "onRateChangeCapture",
+  "onSeeked",
+  "onSeekedCapture",
+  "onSeeking",
+  "onSeekingCapture",
+  "onStalled",
+  "onStalledCapture",
+  "onSuspend",
+  "onSuspendCapture",
+  "onTimeUpdate",
+  "onTimeUpdateCapture",
+  "onVolumeChange",
+  "onVolumeChangeCapture",
+  "onWaiting",
+  "onWaitingCapture",
+  // MouseEvents
+  "onAuxClick",
+  "onAuxClickCapture",
+  "onClick",
+  "onClickCapture",
+  "onContextMenu",
+  "onContextMenuCapture",
+  "onDoubleClick",
+  "onDoubleClickCapture",
+  "onDrag",
+  "onDragCapture",
+  "onDragEnd",
+  "onDragEndCapture",
+  "onDragEnter",
+  "onDragEnterCapture",
+  "onDragExit",
+  "onDragExitCapture",
+  "onDragLeave",
+  "onDragLeaveCapture",
+  "onDragOver",
+  "onDragOverCapture",
+  "onDragStart",
+  "onDragStartCapture",
+  "onDrop",
+  "onDropCapture",
+  "onMouseDown",
+  "onMouseDownCapture",
+  "onMouseEnter",
+  "onMouseLeave",
+  "onMouseMove",
+  "onMouseMoveCapture",
+  "onMouseOut",
+  "onMouseOutCapture",
+  "onMouseOver",
+  "onMouseOverCapture",
+  "onMouseUp",
+  "onMouseUpCapture",
+  // Selection Events
+  "onSelect",
+  "onSelectCapture",
+  // Touch Events
+  "onTouchCancel",
+  "onTouchCancelCapture",
+  "onTouchEnd",
+  "onTouchEndCapture",
+  "onTouchMove",
+  "onTouchMoveCapture",
+  "onTouchStart",
+  "onTouchStartCapture",
+  // Pointer Events
+  "onPointerDown",
+  "onPointerDownCapture",
+  "onPointerMove",
+  "onPointerMoveCapture",
+  "onPointerUp",
+  "onPointerUpCapture",
+  "onPointerCancel",
+  "onPointerCancelCapture",
+  "onPointerEnter",
+  "onPointerEnterCapture",
+  "onPointerLeave",
+  "onPointerLeaveCapture",
+  "onPointerOver",
+  "onPointerOverCapture",
+  "onPointerOut",
+  "onPointerOutCapture",
+  "onGotPointerCapture",
+  "onGotPointerCaptureCapture",
+  "onLostPointerCapture",
+  "onLostPointerCaptureCapture",
+  // UI Events
+  "onScroll",
+  "onScrollCapture",
+  // Wheel Events
+  "onWheel",
+  "onWheelCapture",
+  // Animation Events
+  "onAnimationStart",
+  "onAnimationStartCapture",
+  "onAnimationEnd",
+  "onAnimationEndCapture",
+  "onAnimationIteration",
+  "onAnimationIterationCapture",
+  // Transition Events
+  "onTransitionEnd",
+  "onTransitionEndCapture"
+];
+
+// src/hooks/useEditableProps.ts
+var useEditableProps = (editableProps = {}) => {
+  const { id } = editableProps;
+  const editor = useEditorRef(id);
+  const selectors = usePlateSelectors(id);
+  const versionDecorate = selectors.versionDecorate();
+  const readOnly = selectors.readOnly();
+  const storeDecorate = selectors.decorate();
+  const storeRenderLeaf = selectors.renderLeaf();
+  const storeRenderElement = selectors.renderElement();
+  const decorateMemo = React__default.default.useMemo(() => {
+    return pipeDecorate(editor, storeDecorate != null ? storeDecorate : editableProps == null ? void 0 : editableProps.decorate);
+  }, [editableProps == null ? void 0 : editableProps.decorate, editor, storeDecorate]);
+  const decorate = React__default.default.useMemo(() => {
+    if (!versionDecorate || !decorateMemo)
+      return;
+    return (entry) => decorateMemo(entry);
+  }, [decorateMemo, versionDecorate]);
+  const renderElement = React__default.default.useMemo(() => {
+    return pipeRenderElement(
+      editor,
+      storeRenderElement != null ? storeRenderElement : editableProps == null ? void 0 : editableProps.renderElement
+    );
+  }, [editableProps == null ? void 0 : editableProps.renderElement, editor, storeRenderElement]);
+  const renderLeaf = React__default.default.useMemo(() => {
+    return pipeRenderLeaf(editor, storeRenderLeaf != null ? storeRenderLeaf : editableProps == null ? void 0 : editableProps.renderLeaf);
+  }, [editableProps == null ? void 0 : editableProps.renderLeaf, editor, storeRenderLeaf]);
+  const props = index$5.useDeepCompareMemo(() => {
+    const _props = {
+      decorate,
+      renderElement,
+      renderLeaf
+    };
+    if (index$3.isDefined(readOnly)) {
+      _props.readOnly = readOnly;
+    }
+    DOM_HANDLERS.forEach((handlerKey) => {
+      const handler = pipeHandler(editor, {
+        editableProps,
+        handlerKey
+      });
+      if (handler) {
+        _props[handlerKey] = handler;
+      }
+    });
+    return _props;
+  }, [decorate, editableProps, renderElement, renderLeaf, readOnly]);
+  return index$5.useDeepCompareMemo(
+    () => __spreadValues(__spreadValues({}, omit.default(editableProps, [...DOM_HANDLERS, "renderElement", "renderLeaf"])), props),
+    [editableProps, props]
+  );
+};
+var useSlateProps = ({
+  id
+}) => {
+  const editor = useEditorRef(id);
+  const value = usePlateSelectors(id).value();
+  const setValue = usePlateActions(id).value();
+  const onChangeProp = usePlateSelectors(id).onChange();
+  const onChange = React__default.default.useCallback(
+    (newValue) => {
+      const eventIsHandled = pipeOnChange(editor)(newValue);
+      if (!eventIsHandled) {
+        onChangeProp == null ? void 0 : onChangeProp(newValue);
+      }
+      setValue(newValue);
+    },
+    [editor, setValue, onChangeProp]
+  );
+  return React__default.default.useMemo(() => {
+    return {
+      key: editor.key,
+      editor,
+      onChange,
+      value,
+      initialValue: value
+    };
+  }, [editor, onChange, value]);
+};
+var PlateControllerEffect = ({
+  id: idProp
+}) => {
+  const idFromStore = usePlateId();
+  const id = idProp != null ? idProp : idFromStore;
+  const currentStoreAtom = React__default.default.useMemo(
+    () => index_modern.focusAtom(
+      plateControllerStore.atom.editorStores,
+      (optic) => optic.prop(id)
+    ),
+    [id]
+  );
+  const setCurrentStore = usePlateControllerActions().atom(currentStoreAtom, {
+    warnIfNoStore: false
+  });
+  const store = usePlateStore(id).store();
+  const primary = usePlateSelectors(id).primary();
+  const setPrimaryEditorIds = usePlateControllerActions().primaryEditorIds({
+    warnIfNoStore: false
+  });
+  const focused = slateReact.useFocused();
+  const setActiveId = usePlateControllerActions().activeId({
+    warnIfNoStore: false
+  });
+  React__default.default.useEffect(() => {
+    setCurrentStore(store != null ? store : null);
+    return () => {
+      setCurrentStore(null);
+      setActiveId((activeId) => activeId === id ? null : activeId);
+    };
+  }, [store, setCurrentStore, setActiveId, id]);
+  React__default.default.useEffect(() => {
+    if (primary) {
+      setPrimaryEditorIds((ids) => [...ids, id]);
+      return () => {
+        setPrimaryEditorIds((ids) => ids.filter((i) => i !== id));
+      };
+    }
+  }, [id, primary, setPrimaryEditorIds]);
+  React__default.default.useEffect(() => {
+    if (id && focused) {
+      setActiveId(id);
+    }
+  }, [id, focused, setActiveId]);
+  return null;
+};
+function PlateSlate({
+  id,
+  children
+}) {
+  var _a;
+  const slateProps = useSlateProps({ id });
+  const editor = useEditorRef(id);
+  let aboveSlate = /* @__PURE__ */ React__default.default.createElement(slateReact.Slate, __spreadValues({}, slateProps), children);
+  (_a = editor.plugins) == null ? void 0 : _a.forEach((plugin) => {
+    const { renderAboveSlate: RenderAboveSlate } = plugin;
+    if (RenderAboveSlate)
+      aboveSlate = /* @__PURE__ */ React__default.default.createElement(RenderAboveSlate, null, aboveSlate);
+  });
+  return aboveSlate;
+}
+
+// src/components/PlateContent.tsx
+var PlateContent = React__default.default.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { renderEditable } = _b, props = __objRest(_b, ["renderEditable"]);
+    const { id } = props;
+    const editor = useEditorRef(id);
+    if (!editor) {
+      throw new Error(
+        "Editor not found. Please ensure that PlateContent is rendered below Plate."
+      );
+    }
+    const editableProps = useEditableProps(props);
+    const editable = /* @__PURE__ */ React__default.default.createElement(slateReact.Editable, __spreadValues({ ref }, editableProps));
+    let afterEditable = null;
+    let beforeEditable = null;
+    editor.plugins.forEach((plugin) => {
+      const {
+        renderBeforeEditable: RenderBeforeEditable,
+        renderAfterEditable: RenderAfterEditable
+      } = plugin;
+      if (RenderAfterEditable) {
+        afterEditable = /* @__PURE__ */ React__default.default.createElement(React__default.default.Fragment, null, afterEditable, /* @__PURE__ */ React__default.default.createElement(RenderAfterEditable, __spreadValues({}, editableProps)));
+      }
+      if (RenderBeforeEditable) {
+        beforeEditable = /* @__PURE__ */ React__default.default.createElement(React__default.default.Fragment, null, beforeEditable, /* @__PURE__ */ React__default.default.createElement(RenderBeforeEditable, __spreadValues({}, editableProps)));
+      }
+    });
+    let aboveEditable = /* @__PURE__ */ React__default.default.createElement(React__default.default.Fragment, null, beforeEditable, renderEditable ? renderEditable(editable) : editable, /* @__PURE__ */ React__default.default.createElement(EditorMethodsEffect, { id }), /* @__PURE__ */ React__default.default.createElement(EditorStateEffect, { id }), /* @__PURE__ */ React__default.default.createElement(EditorRefEffect, { id }), /* @__PURE__ */ React__default.default.createElement(PlateControllerEffect, { id }), afterEditable);
+    editor.plugins.forEach((plugin) => {
+      const { renderAboveEditable: RenderAboveEditable } = plugin;
+      if (RenderAboveEditable)
+        aboveEditable = /* @__PURE__ */ React__default.default.createElement(RenderAboveEditable, null, aboveEditable);
+    });
+    return /* @__PURE__ */ React__default.default.createElement(PlateSlate, { id }, aboveEditable);
+  }
+);
+PlateContent.displayName = "PlateContent";
+
+exports.createAtomStore = index.createAtomStore;
+exports.isHotkeyPressed = reactHotkeysHook_esm.isHotkeyPressed;
+exports.useHotkeys = reactHotkeysHook_esm.useHotkeys;
+exports.createZustandStore = index$1.createZustandStore;
+exports.atom = vanilla.atom;
+exports.DOM_HANDLERS = DOM_HANDLERS;
+exports.DefaultLeaf = DefaultLeaf;
+exports.ELEMENT_DEFAULT = ELEMENT_DEFAULT;
+exports.EXPOSED_STORE_KEYS = EXPOSED_STORE_KEYS;
+exports.EditorMethodsEffect = EditorMethodsEffect;
+exports.EditorRefEffect = EditorRefEffect;
+exports.EditorRefPluginEffect = EditorRefPluginEffect;
+exports.EditorStateEffect = EditorStateEffect;
+exports.ElementProvider = ElementProvider;
+exports.KEY_DESERIALIZE_AST = KEY_DESERIALIZE_AST;
+exports.KEY_DESERIALIZE_HTML = KEY_DESERIALIZE_HTML;
+exports.KEY_EDITOR_PROTOCOL = KEY_EDITOR_PROTOCOL;
+exports.KEY_EVENT_EDITOR = KEY_EVENT_EDITOR;
+exports.KEY_INLINE_VOID = KEY_INLINE_VOID;
+exports.KEY_INSERT_DATA = KEY_INSERT_DATA;
+exports.KEY_LENGTH = KEY_LENGTH;
+exports.KEY_NODE_FACTORY = KEY_NODE_FACTORY;
+exports.KEY_PREV_SELECTION = KEY_PREV_SELECTION;
+exports.PlateContent = PlateContent;
+exports.PlateController = PlateController;
+exports.PlateControllerEffect = PlateControllerEffect;
+exports.PlateSlate = PlateSlate;
+exports.PlateStoreProvider = PlateStoreProvider;
+exports.SCOPE_ELEMENT = SCOPE_ELEMENT;
+exports.applyDeepToNodes = applyDeepToNodes;
+exports.collapseString = collapseString;
+exports.collapseWhiteSpace = collapseWhiteSpace;
+exports.collapseWhiteSpaceChildren = collapseWhiteSpaceChildren;
+exports.collapseWhiteSpaceElement = collapseWhiteSpaceElement;
+exports.collapseWhiteSpaceNode = collapseWhiteSpaceNode;
+exports.collapseWhiteSpaceText = collapseWhiteSpaceText;
+exports.convertDomEventToSyntheticEvent = convertDomEventToSyntheticEvent;
+exports.createDeserializeAstPlugin = createDeserializeAstPlugin;
+exports.createDeserializeHtmlPlugin = createDeserializeHtmlPlugin;
+exports.createEditorProtocolPlugin = createEditorProtocolPlugin;
+exports.createEventEditorPlugin = createEventEditorPlugin;
+exports.createHistoryPlugin = createHistoryPlugin;
+exports.createInlineVoidPlugin = createInlineVoidPlugin;
+exports.createInsertDataPlugin = createInsertDataPlugin;
+exports.createLengthPlugin = createLengthPlugin;
+exports.createNodeFactoryPlugin = createNodeFactoryPlugin;
+exports.createPlateEditor = createPlateEditor;
+exports.createPlateFallbackEditor = createPlateFallbackEditor;
+exports.createPlateStore = createPlateStore;
+exports.createPluginFactory = createPluginFactory;
+exports.createPlugins = createPlugins;
+exports.createPrevSelectionPlugin = createPrevSelectionPlugin;
+exports.createReactPlugin = createReactPlugin;
+exports.deserializeHtml = deserializeHtml;
+exports.deserializeHtmlElement = deserializeHtmlElement;
+exports.deserializeHtmlNode = deserializeHtmlNode;
+exports.deserializeHtmlNodeChildren = deserializeHtmlNodeChildren;
+exports.endInlineFormattingContext = endInlineFormattingContext;
+exports.eventEditorActions = eventEditorActions;
+exports.eventEditorSelectors = eventEditorSelectors;
+exports.eventEditorStore = eventEditorStore;
+exports.flattenDeepPlugins = flattenDeepPlugins;
+exports.getInjectedPlugins = getInjectedPlugins;
+exports.getPlugin = getPlugin;
+exports.getPluginInjectProps = getPluginInjectProps;
+exports.getPluginOptions = getPluginOptions;
+exports.getPluginType = getPluginType;
+exports.getPluginTypes = getPluginTypes;
+exports.getPluginsByKey = getPluginsByKey;
+exports.getRenderNodeProps = getRenderNodeProps;
+exports.getSlateClass = getSlateClass;
+exports.htmlBodyToFragment = htmlBodyToFragment;
+exports.htmlBrToNewLine = htmlBrToNewLine;
+exports.htmlElementToElement = htmlElementToElement;
+exports.htmlElementToLeaf = htmlElementToLeaf;
+exports.htmlStringToDOMNode = htmlStringToDOMNode;
+exports.htmlTextNodeToString = htmlTextNodeToString;
+exports.inferWhiteSpaceRule = inferWhiteSpaceRule;
+exports.inlineTagNames = inlineTagNames;
+exports.isEventHandled = isEventHandled;
+exports.isHtmlBlockElement = isHtmlBlockElement;
+exports.isHtmlElement = isHtmlElement;
+exports.isHtmlInlineElement = isHtmlInlineElement;
+exports.isHtmlText = isHtmlText;
+exports.isLastNonEmptyTextOfInlineFormattingContext = isLastNonEmptyTextOfInlineFormattingContext;
+exports.mergeDeepPlugins = mergeDeepPlugins;
+exports.mergeDeepToNodes = mergeDeepToNodes;
+exports.mockPlugin = mockPlugin;
+exports.normalizeDescendantsToDocumentFragment = normalizeDescendantsToDocumentFragment;
+exports.overridePluginsByKey = overridePluginsByKey;
+exports.parseHtmlDocument = parseHtmlDocument;
+exports.pipeDecorate = pipeDecorate;
+exports.pipeDeserializeHtmlElement = pipeDeserializeHtmlElement;
+exports.pipeDeserializeHtmlLeaf = pipeDeserializeHtmlLeaf;
+exports.pipeHandler = pipeHandler;
+exports.pipeInjectProps = pipeInjectProps;
+exports.pipeInsertDataQuery = pipeInsertDataQuery;
+exports.pipeInsertFragment = pipeInsertFragment;
+exports.pipeOnChange = pipeOnChange;
+exports.pipeRenderElement = pipeRenderElement;
+exports.pipeRenderLeaf = pipeRenderLeaf;
+exports.pipeTransformData = pipeTransformData;
+exports.pipeTransformFragment = pipeTransformFragment;
+exports.plateControllerStore = plateControllerStore;
+exports.plateStore = plateStore;
+exports.pluginDeserializeHtml = pluginDeserializeHtml;
+exports.pluginInjectProps = pluginInjectProps;
+exports.pluginRenderElement = pluginRenderElement;
+exports.pluginRenderLeaf = pluginRenderLeaf;
+exports.resetEditor = resetEditor;
+exports.resetEditorChildren = resetEditorChildren;
+exports.setDefaultPlugin = setDefaultPlugin;
+exports.setPlatePlugins = setPlatePlugins;
+exports.upsertInlineFormattingContext = upsertInlineFormattingContext;
+exports.useEditableProps = useEditableProps;
+exports.useEditorRef = useEditorRef;
+exports.useEditorSelection = useEditorSelection;
+exports.useEditorSelector = useEditorSelector;
+exports.useElement = useElement;
+exports.useElementStore = useElementStore;
+exports.useIncrementVersion = useIncrementVersion;
+exports.usePlateActions = usePlateActions;
+exports.usePlateControllerActions = usePlateControllerActions;
+exports.usePlateControllerEditorStore = usePlateControllerEditorStore;
+exports.usePlateControllerExists = usePlateControllerExists;
+exports.usePlateControllerSelectors = usePlateControllerSelectors;
+exports.usePlateControllerStore = usePlateControllerStore;
+exports.usePlateEditorStore = usePlateEditorStore;
+exports.usePlateId = usePlateId;
+exports.usePlateSelectors = usePlateSelectors;
+exports.usePlateStore = usePlateStore;
+exports.useRedecorate = useRedecorate;
+exports.useSlateProps = useSlateProps;
+exports.withEditorProtocol = withEditorProtocol;
+exports.withHOC = withHOC;
+exports.withInlineVoid = withInlineVoid;
+exports.withInsertData = withInsertData;
+exports.withLength = withLength;
+exports.withPlate = withPlate;
+exports.withTHistory = withTHistory;
+exports.withTReact = withTReact;