lexical 0.25.1-nightly.20250227.0 → 0.25.1-nightly.20250228.0

package/Lexical.dev.js

@@ -8,6 +8,8 @@
 
 'use strict';
 
+var lexical = require('lexical');
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -176,6 +178,7 @@ const TEXT_TYPE_TO_MODE = {
   [IS_SEGMENTED]: 'segmented',
   [IS_TOKEN]: 'token'
 };
+const NODE_STATE_KEY = '$';
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -456,6 +459,601 @@ function initMutationObserver(editor) {
   });
 }
 
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function coerceToJSON(v) {
+  return v;
+}
+
+/**
+ * The return value of {@link createState}, for use with
+ * {@link $getState} and {@link $setState}.
+ */
+class StateConfig {
+  /** The string key used when serializing this state to JSON */
+
+  /** The parse function from the StateValueConfig passed to createState */
+
+  /**
+   * The unparse function from the StateValueConfig passed to createState,
+   * with a default that is simply a pass-through that assumes the value is
+   * JSON serializable.
+   */
+
+  /**
+   * An equality function from the StateValueConfig, with a default of
+   * Object.is.
+   */
+
+  /**
+   * The result of `stateValueConfig.parse(undefined)`, which is computed only
+   * once and used as the default value. When the current value `isEqual` to
+   * the `defaultValue`, it will not be serialized to JSON.
+   */
+
+  constructor(key, stateValueConfig) {
+    this.key = key;
+    this.parse = stateValueConfig.parse.bind(stateValueConfig);
+    this.unparse = (stateValueConfig.unparse || coerceToJSON).bind(stateValueConfig);
+    this.isEqual = (stateValueConfig.isEqual || Object.is).bind(stateValueConfig);
+    this.defaultValue = this.parse(undefined);
+  }
+}
+
+/**
+ * For advanced use cases, using this type is not recommended unless
+ * it is required (due to TypeScript's lack of features like
+ * higher-kinded types).
+ *
+ * A {@link StateConfig} type with any key and any value that can be
+ * used in situations where the key and value type can not be known,
+ * such as in a generic constraint when working with a collection of
+ * StateConfig.
+ *
+ * {@link StateConfigKey} and {@link StateConfigValue} will be
+ * useful when this is used as a generic constraint.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * Get the value type (V) from a StateConfig
+ */
+
+/**
+ * Get the key type (K) from a StateConfig
+ */
+
+/**
+ * A value type, or an updater for that value type. For use with
+ * {@link $setState} or any user-defined wrappers around it.
+ */
+
+/**
+ * Configure a value to be used with StateConfig.
+ *
+ * The value type should be inferred from the definition of parse.
+ *
+ * If the value type is not JSON serializable, then unparse must also be provided.
+ *
+ * Values should be treated as immutable, much like React.useState. Mutating
+ * stored values directly will cause unpredictable behavior, is not supported,
+ * and may trigger errors in the future.
+ *
+ * @example
+ * ```ts
+ * const numberOrNullState = createState('numberOrNull', {parse: (v) => typeof v === 'number' ? v : null});
+ * //    ^? State<'numberOrNull', StateValueConfig<number | null>>
+ * const numberState = createState('number', {parse: (v) => typeof v === 'number' ? v : 0});
+ * //    ^? State<'number', StateValueConfig<number>>
+ * ```
+ *
+ * Only the parse option is required, it is generally not useful to
+ * override `unparse` or `isEqual`. However, if you are using
+ * non-primitive types such as Array, Object, Date, or something
+ * more exotic then you would want to override this. In these
+ * cases you might want to reach for third party libraries.
+ *
+ * @example
+ * ```ts
+ * const isoDateState = createState('isoDate', {
+ *   parse: (v): null | Date => {
+ *     const date = typeof v === 'string' ? new Date(v) : null;
+ *     return date && !isNaN(date.valueOf()) ? date : null;
+ *   }
+ *   isEqual: (a, b) => a === b || (a && b && a.valueOf() === b.valueOf()),
+ *   unparse: (v) => v && v.toString()
+ * });
+ * ```
+ *
+ * You may find it easier to write a parse function using libraries like
+ * zod, valibot, ajv, Effect, TypeBox, etc. perhaps with a wrapper function.
+ */
+
+/**
+ * Create a StateConfig for the given string key and StateValueConfig.
+ *
+ * The key must be locally unique. In dev you wil get a key collision error
+ * when you use two separate StateConfig on the same node with the same key.
+ *
+ * The returned StateConfig value should be used with {@link $getState} and
+ * {@link $setState}.
+ *
+ * @param key The key to use
+ * @param valueConfig Configuration for the value type
+ * @returns a StateConfig
+ */
+function createState(key, valueConfig) {
+  return new StateConfig(key, valueConfig);
+}
+
+/**
+ * Given two versions of a node and a stateConfig, compare their state values
+ * using `$getState(nodeVersion, stateConfig, 'direct')`.
+ * If the values are equal according to `stateConfig.isEqual`, return `null`,
+ * otherwise return `[value, prevValue]`.
+ *
+ * This is useful for implementing updateDOM. Note that the `'direct'`
+ * version argument is used for both nodes.
+ *
+ * @param node Any LexicalNode
+ * @param prevNode A previous version of node
+ * @param stateConfig The configuration of the state to read
+ * @returns `[value, prevValue]` if changed, otherwise `null`
+ */
+function $getStateChange(node, prevNode, stateConfig) {
+  const value = $getState(node, stateConfig, 'direct');
+  const prevValue = $getState(prevNode, stateConfig, 'direct');
+  return stateConfig.isEqual(value, prevValue) ? null : [value, prevValue];
+}
+
+/**
+ * The accessor for working with node state. This will read the value for the
+ * state on the given node, and will return `stateConfig.defaultValue` if the
+ * state has never been set on this node.
+ *
+ * The `version` parameter is optional and should generally be `'latest'`,
+ * consistent with the behavior of other node methods and functions,
+ * but for certain use cases such as `updateDOM` you may have a need to
+ * use `'direct'` to read the state from a previous version of the node.
+ *
+ * For very advanced use cases, you can expect that 'direct' does not
+ * require an editor state, just like directly accessing other properties
+ * of a node without an accessor (e.g. `textNode.__text`).
+ *
+ * @param node Any LexicalNode
+ * @param stateConfig The configuration of the state to read
+ * @param version The default value 'latest' will read the latest version of the node state, 'direct' will read the version that is stored on this LexicalNode which not reflect the version used in the current editor state
+ * @returns The current value from the state, or the default value provided by the configuration.
+ */
+function $getState(node, stateConfig, version = 'latest') {
+  const latestOrDirectNode = version === 'latest' ? node.getLatest() : node;
+  const state = latestOrDirectNode.__state;
+  if (state) {
+    $checkCollision(node, stateConfig, state);
+    return state.getValue(stateConfig);
+  }
+  return stateConfig.defaultValue;
+}
+
+/**
+ * @internal
+ *
+ * Register the config to this node's sharedConfigMap and throw an exception in
+ * `true` when a collision is detected.
+ */
+function $checkCollision(node, stateConfig, state) {
+  {
+    const collision = state.sharedConfigMap.get(stateConfig.key);
+    if (collision !== undefined && collision !== stateConfig) {
+      {
+        throw Error(`$setState: State key collision ${JSON.stringify(stateConfig.key)} detected in ${node.constructor.name} node with type ${node.getType()} and key ${node.getKey()}. Only one StateConfig with a given key should be used on a node.`);
+      }
+    }
+  }
+}
+
+/**
+ * Set the state defined by stateConfig on node. Like with `React.useState`
+ * you may directly specify the value or use an updater function that will
+ * be called with the previous value of the state on that node (which will
+ * be the `stateConfig.defaultValue` if not set).
+ *
+ * When an updater function is used, the node will only be marked dirty if
+ * `stateConfig.isEqual(prevValue, value)` is false.
+ *
+ * @example
+ * ```ts
+ * const toggle = createState('toggle', {parse: Boolean});
+ * // set it direction
+ * $setState(node, counterState, true);
+ * // use an updater
+ * $setState(node, counterState, (prev) => !prev);
+ * ```
+ *
+ * @param node The LexicalNode to set the state on
+ * @param stateConfig The configuration for this state
+ * @param valueOrUpdater The value or updater function
+ * @returns node
+ */
+function $setState(node, stateConfig, valueOrUpdater) {
+  errorOnReadOnly();
+  let value;
+  if (typeof valueOrUpdater === 'function') {
+    const latest = node.getLatest();
+    const prevValue = $getState(latest, stateConfig);
+    value = valueOrUpdater(prevValue);
+    if (stateConfig.isEqual(prevValue, value)) {
+      return latest;
+    }
+  } else {
+    value = valueOrUpdater;
+  }
+  const writable = node.getWritable();
+  const state = $getWritableNodeState(writable);
+  $checkCollision(node, stateConfig, state);
+  state.updateFromKnown(stateConfig, value);
+  return writable;
+}
+/**
+ * @internal
+ */
+class NodeState {
+  /**
+   * @internal
+   *
+   * Track the (versioned) node that this NodeState was created for, to
+   * facilitate copy-on-write for NodeState. When a LexicalNode is cloned,
+   * it will *reference* the NodeState from its prevNode. From the nextNode
+   * you can continue to read state without copying, but the first $setState
+   * will trigger a copy of the prevNode's NodeState with the node property
+   * updated.
+   */
+
+  /**
+   * @internal
+   *
+   * State that has already been parsed in a get state, so it is safe. (can be returned with
+   * just a cast since the proof was given before).
+   *
+   * Note that it uses StateConfig, so in addition to (1) the CURRENT VALUE, it has access to
+   * (2) the State key (3) the DEFAULT VALUE and (4) the PARSE FUNCTION
+   */
+
+  /**
+   * @internal
+   *
+   * A copy of serializedNode[NODE_STATE_KEY] that is made when JSON is
+   * imported but has not been parsed yet.
+   *
+   * It stays here until a get state requires us to parse it, and since we
+   * then know the value is safe we move it to knownState and garbage collect
+   * it at the next version.
+   *
+   * Note that since only string keys are used here, we can only allow this
+   * state to pass-through on export or on the next version since there is
+   * no known value configuration. This pass-through is to support scenarios
+   * where multiple versions of the editor code are working in parallel so
+   * an old version of your code doesnt erase metadata that was
+   * set by a newer version of your code.
+   */
+
+  /**
+   * @internal
+   *
+   * This sharedConfigMap is preserved across all versions of a given node and
+   * remains writable. It is how keys are resolved to configuration.
+   */
+
+  /**
+   * @internal
+   *
+   * The count of known or unknown keys in this state, ignoring the
+   * intersection between the two sets.
+   */
+
+  /**
+   * @internal
+   */
+  constructor(node, sharedConfigMap = new Map(), unknownState = undefined, knownState = new Map(), size = undefined) {
+    this.node = node;
+    this.sharedConfigMap = sharedConfigMap;
+    this.unknownState = unknownState;
+    this.knownState = knownState;
+    const computedSize = size !== undefined ? size : computeSize(sharedConfigMap, unknownState, knownState);
+    {
+      if (!(size === undefined || computedSize === size)) {
+        throw Error(`NodeState: size != computedSize (${String(size)} != ${String(computedSize)})`);
+      }
+      for (const stateConfig of knownState.keys()) {
+        if (!sharedConfigMap.has(stateConfig.key)) {
+          throw Error(`NodeState: sharedConfigMap missing knownState key ${stateConfig.key}`);
+        }
+      }
+    }
+    this.size = computedSize;
+  }
+
+  /** @internal */
+  getValue(stateConfig) {
+    const known = this.knownState.get(stateConfig);
+    if (known !== undefined) {
+      return known;
+    }
+    this.sharedConfigMap.set(stateConfig.key, stateConfig);
+    let parsed = stateConfig.defaultValue;
+    if (this.unknownState && stateConfig.key in this.unknownState) {
+      const jsonValue = this.unknownState[stateConfig.key];
+      if (jsonValue !== undefined) {
+        parsed = stateConfig.parse(jsonValue);
+      }
+      // Only update if the key was unknown
+      this.updateFromKnown(stateConfig, parsed);
+    }
+    return parsed;
+  }
+
+  /**
+   * @internal
+   *
+   * Used only for advanced use cases, such as collab. The intent here is to
+   * allow you to diff states with a more stable interface than the properties
+   * of this class.
+   */
+  getInternalState() {
+    return [this.unknownState, this.knownState];
+  }
+
+  /**
+   * Encode this NodeState to JSON in the format that its node expects.
+   * This returns `{[NODE_STATE_KEY]?: UnknownStateRecord}` rather than
+   * `UnknownStateRecord | undefined` so that we can support flattening
+   * specific entries in the future when nodes can declare what
+   * their required StateConfigs are.
+   */
+  toJSON() {
+    const state = {
+      ...this.unknownState
+    };
+    for (const [stateConfig, v] of this.knownState) {
+      if (stateConfig.isEqual(v, stateConfig.defaultValue)) {
+        delete state[stateConfig.key];
+      } else {
+        state[stateConfig.key] = stateConfig.unparse(v);
+      }
+    }
+    return undefinedIfEmpty(state) ? {
+      [NODE_STATE_KEY]: state
+    } : {};
+  }
+
+  /**
+   * @internal
+   *
+   * A NodeState is writable when the node to update matches
+   * the node associated with the NodeState. This basically
+   * mirrors how the EditorState NodeMap works, but in a
+   * bottom-up organization rather than a top-down organization.
+   *
+   * This allows us to implement the same "copy on write"
+   * pattern for state, without having the state version
+   * update every time the node version changes (e.g. when
+   * its parent or siblings change).
+   *
+   * @param node The node to associate with the state
+   * @returns The next writaable state
+   */
+  getWritable(node) {
+    if (this.node === node) {
+      return this;
+    }
+    const nextKnownState = new Map(this.knownState);
+    const nextUnknownState = cloneUnknownState(this.unknownState);
+    if (nextUnknownState) {
+      // Garbage collection
+      for (const stateConfig of nextKnownState.keys()) {
+        delete nextUnknownState[stateConfig.key];
+      }
+    }
+    return new NodeState(node, this.sharedConfigMap, undefinedIfEmpty(nextUnknownState), nextKnownState, this.size);
+  }
+
+  /** @internal */
+  updateFromKnown(stateConfig, value) {
+    const key = stateConfig.key;
+    this.sharedConfigMap.set(key, stateConfig);
+    const {
+      knownState,
+      unknownState
+    } = this;
+    if (!(knownState.has(stateConfig) || unknownState && key in unknownState)) {
+      this.size++;
+    }
+    knownState.set(stateConfig, value);
+  }
+
+  /**
+   * @internal
+   *
+   * This is intended for advanced use cases only, such
+   * as collab or dev tools.
+   *
+   * Update a single key value pair from unknown state,
+   * parsing it if the key is known to this node. This is
+   * basically like updateFromJSON, but the effect is
+   * isolated to a single entry.
+   *
+   * @param k The string key from an UnknownStateRecord
+   * @param v The unknown value from an UnknownStateRecord
+   */
+  updateFromUnknown(k, v) {
+    const stateConfig = this.sharedConfigMap.get(k);
+    if (stateConfig) {
+      this.updateFromKnown(stateConfig, stateConfig.parse(v));
+    } else {
+      this.unknownState = this.unknownState || {};
+      if (!(k in this.unknownState)) {
+        this.size++;
+      }
+      this.unknownState[k] = v;
+    }
+  }
+
+  /**
+   * @internal
+   *
+   * Reset all existing state to default or empty values,
+   * and perform any updates from the given unknownState.
+   *
+   * This is used when initializing a node's state from JSON,
+   * or when resetting a node's state from JSON.
+   *
+   * @param unknownState The new state in serialized form
+   */
+  updateFromJSON(unknownState) {
+    const {
+      knownState
+    } = this;
+    // Reset all known state to defaults
+    for (const stateConfig of knownState.keys()) {
+      knownState.set(stateConfig, stateConfig.defaultValue);
+    }
+    // Since we are resetting all state to this new record,
+    // the size starts at the number of known keys
+    // and will be updated as we traverse the new state
+    this.size = knownState.size;
+    this.unknownState = {};
+    if (unknownState) {
+      for (const [k, v] of Object.entries(unknownState)) {
+        this.updateFromUnknown(k, v);
+      }
+    }
+    this.unknownState = undefinedIfEmpty(this.unknownState);
+  }
+}
+function computeSize(sharedConfigMap, unknownState, knownState) {
+  let size = knownState.size;
+  if (unknownState) {
+    for (const k in unknownState) {
+      const sharedConfig = sharedConfigMap.get(k);
+      if (!sharedConfig || !knownState.has(sharedConfig)) {
+        size++;
+      }
+    }
+  }
+  return size;
+}
+
+/**
+ * Return obj if it is an object with at least one property, otherwise
+ * return undefined.
+ */
+function undefinedIfEmpty(obj) {
+  if (obj) {
+    for (const key in obj) {
+      return obj;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Return undefined if unknownState is undefined or an empty object,
+ * otherwise return a shallow clone of it.
+ */
+function cloneUnknownState(unknownState) {
+  return undefinedIfEmpty(unknownState) && {
+    ...unknownState
+  };
+}
+
+/**
+ * @internal
+ *
+ * Only for direct use in very advanced integrations, such as lexical-yjs.
+ * Typically you would only use {@link createState}, {@link $getState}, and
+ * {@link $setState}. This is effectively the preamble for {@link $setState}.
+ */
+function $getWritableNodeState(node) {
+  const writable = node.getWritable();
+  const state = writable.__state ? writable.__state.getWritable(writable) : new NodeState(writable);
+  writable.__state = state;
+  return state;
+}
+
+/**
+ * @internal
+ *
+ * This is used to implement LexicalNode.updateFromJSON and is
+ * not intended to be exported from the package.
+ *
+ * @param node any LexicalNode
+ * @param unknownState undefined or a serialized State
+ * @returns A writable version of node, with the state set.
+ */
+function $updateStateFromJSON(node, unknownState) {
+  const writable = node.getWritable();
+  if (unknownState || writable.__state) {
+    $getWritableNodeState(node).updateFromJSON(unknownState);
+  }
+  return writable;
+}
+
+/**
+ * @internal
+ *
+ * Return true if the two nodes have equivalent NodeState, to be used
+ * to determine when TextNode are being merged, not a lot of use cases
+ * otherwise.
+ */
+function $nodeStatesAreEquivalent(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && a.size !== b.size) {
+    return false;
+  }
+  const keys = new Set();
+  const hasUnequalMapEntry = (sourceState, otherState) => {
+    for (const [stateConfig, value] of sourceState.knownState) {
+      if (keys.has(stateConfig.key)) {
+        continue;
+      }
+      keys.add(stateConfig.key);
+      const otherValue = otherState ? otherState.getValue(stateConfig) : stateConfig.defaultValue;
+      if (otherValue !== value && !stateConfig.isEqual(otherValue, value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const hasUnequalRecordEntry = (sourceState, otherState) => {
+    const {
+      unknownState
+    } = sourceState;
+    const otherUnknownState = otherState ? otherState.unknownState : undefined;
+    if (unknownState) {
+      for (const [key, value] of Object.entries(unknownState)) {
+        if (keys.has(key)) {
+          continue;
+        }
+        keys.add(key);
+        const otherValue = otherUnknownState ? otherUnknownState[key] : undefined;
+        if (value !== otherValue) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  return !(a && hasUnequalMapEntry(a, b) || b && hasUnequalMapEntry(b, a) || a && hasUnequalRecordEntry(a, b) || b && hasUnequalRecordEntry(b, a));
+}
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -471,7 +1069,9 @@ function $canSimpleTextNodesBeMerged(node1, node2) {
   const node2Mode = node2.__mode;
   const node2Format = node2.__format;
   const node2Style = node2.__style;
-  return (node1Mode === null || node1Mode === node2Mode) && (node1Format === null || node1Format === node2Format) && (node1Style === null || node1Style === node2Style);
+  const node1State = node1.__state;
+  const node2State = node2.__state;
+  return (node1Mode === null || node1Mode === node2Mode) && (node1Format === null || node1Format === node2Format) && (node1Style === null || node1Style === node2Style) && (node1.__state === null || node1State === node2State || $nodeStatesAreEquivalent(node1State, node2State));
 }
 function $mergeTextNodes(node1, node2) {
   const writableNode1 = node1.mergeWithSibling(node2);
@@ -2250,6 +2850,8 @@ class LexicalNode {
 
   /** @internal */
 
+  /** @internal */
+
   // Flow doesn't support abstract classes unfortunately, so we can't _force_
   // subclasses of Node to implement statics. All subclasses of Node should have
   // a static getType and clone method though. We define getType and clone here so we can call it
@@ -2333,6 +2935,7 @@ class LexicalNode {
     this.__parent = prevNode.__parent;
     this.__next = prevNode.__next;
     this.__prev = prevNode.__prev;
+    this.__state = prevNode.__state;
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -2342,6 +2945,12 @@ class LexicalNode {
     this.__parent = null;
     this.__prev = null;
     this.__next = null;
+    Object.defineProperty(this, '__state', {
+      configurable: true,
+      enumerable: false,
+      value: undefined,
+      writable: true
+    });
     $setNodeKey(this, key);
     {
       if (this.__type !== 'root') {
@@ -2859,9 +3468,12 @@ class LexicalNode {
    *
    * */
   exportJSON() {
+    // eslint-disable-next-line dot-notation
+    const state = this.__state ? this.__state.toJSON() : undefined;
     return {
       type: this.__type,
-      version: 1
+      version: 1,
+      ...state
     };
   }
 
@@ -2907,7 +3519,7 @@ class LexicalNode {
    * ```
    **/
   updateFromJSON(serializedNode) {
-    return this;
+    return $updateStateFromJSON(this, serializedNode[lexical.NODE_STATE_KEY]);
   }
 
   /**
@@ -9644,7 +10256,7 @@ class LexicalEditor {
     };
   }
 }
-LexicalEditor.version = "0.25.1-nightly.20250227.0+dev.cjs";
+LexicalEditor.version = "0.25.1-nightly.20250228.0+dev.cjs";
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -12318,10 +12930,13 @@ exports.$getPreviousSelection = $getPreviousSelection;
 exports.$getRoot = $getRoot;
 exports.$getSelection = $getSelection;
 exports.$getSiblingCaret = $getSiblingCaret;
+exports.$getState = $getState;
+exports.$getStateChange = $getStateChange;
 exports.$getTextContent = $getTextContent;
 exports.$getTextNodeOffset = $getTextNodeOffset;
 exports.$getTextPointCaret = $getTextPointCaret;
 exports.$getTextPointCaretSlice = $getTextPointCaretSlice;
+exports.$getWritableNodeState = $getWritableNodeState;
 exports.$hasAncestor = $hasAncestor;
 exports.$hasUpdateTag = $hasUpdateTag;
 exports.$insertNodes = $insertNodes;
@@ -12356,6 +12971,7 @@ exports.$setCompositionKey = $setCompositionKey;
 exports.$setPointFromCaret = $setPointFromCaret;
 exports.$setSelection = $setSelection;
 exports.$setSelectionFromCaretRange = $setSelectionFromCaretRange;
+exports.$setState = $setState;
 exports.$splitNode = $splitNode;
 exports.$updateRangeSelectionFromCaretRange = $updateRangeSelectionFromCaretRange;
 exports.ArtificialNode__DO_NOT_USE = ArtificialNode__DO_NOT_USE;
@@ -12414,6 +13030,7 @@ exports.KEY_TAB_COMMAND = KEY_TAB_COMMAND;
 exports.LineBreakNode = LineBreakNode;
 exports.MOVE_TO_END = MOVE_TO_END;
 exports.MOVE_TO_START = MOVE_TO_START;
+exports.NODE_STATE_KEY = NODE_STATE_KEY;
 exports.OUTDENT_CONTENT_COMMAND = OUTDENT_CONTENT_COMMAND;
 exports.PASTE_COMMAND = PASTE_COMMAND;
 exports.ParagraphNode = ParagraphNode;
@@ -12429,6 +13046,7 @@ exports.TextNode = TextNode;
 exports.UNDO_COMMAND = UNDO_COMMAND;
 exports.createCommand = createCommand;
 exports.createEditor = createEditor;
+exports.createState = createState;
 exports.flipDirection = flipDirection;
 exports.getDOMOwnerDocument = getDOMOwnerDocument;
 exports.getDOMSelection = getDOMSelection;