@ekz/lexical-offset 0.40.0

package/EkzLexicalOffset.dev.js

@@ -0,0 +1,336 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict';
+
+var lexical = require('@ekz/lexical');
+
+/**
+ * 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.
+ *
+ */
+
+// Do not require this module directly! Use normal `invariant` calls.
+
+function formatDevErrorMessage(message) {
+  throw new Error(message);
+}
+
+class OffsetView {
+  _offsetMap;
+  _firstNode;
+  _blockOffsetSize;
+  constructor(offsetMap, firstNode, blockOffsetSize = 1) {
+    this._offsetMap = offsetMap;
+    this._firstNode = firstNode;
+    this._blockOffsetSize = blockOffsetSize;
+  }
+  createSelectionFromOffsets(originalStart, originalEnd, diffOffsetView) {
+    const firstNode = this._firstNode;
+    if (firstNode === null) {
+      return null;
+    }
+    let start = originalStart;
+    let end = originalEnd;
+    let startOffsetNode = $searchForNodeWithOffset(firstNode, start, this._blockOffsetSize);
+    let endOffsetNode = $searchForNodeWithOffset(firstNode, end, this._blockOffsetSize);
+    if (diffOffsetView !== undefined) {
+      start = $getAdjustedOffsetFromDiff(start, startOffsetNode, diffOffsetView, this, this._blockOffsetSize);
+      startOffsetNode = $searchForNodeWithOffset(firstNode, start, this._blockOffsetSize);
+      end = $getAdjustedOffsetFromDiff(end, endOffsetNode, diffOffsetView, this, this._blockOffsetSize);
+      endOffsetNode = $searchForNodeWithOffset(firstNode, end, this._blockOffsetSize);
+    }
+    if (startOffsetNode === null || endOffsetNode === null) {
+      return null;
+    }
+    let startKey = startOffsetNode.key;
+    let endKey = endOffsetNode.key;
+    const startNode = lexical.$getNodeByKey(startKey);
+    const endNode = lexical.$getNodeByKey(endKey);
+    if (startNode === null || endNode === null) {
+      return null;
+    }
+    let startOffset = 0;
+    let endOffset = 0;
+    let startType = 'element';
+    let endType = 'element';
+    if (startOffsetNode.type === 'text') {
+      startOffset = start - startOffsetNode.start;
+      startType = 'text';
+      // If we are at the edge of a text node and we
+      // don't have a collapsed selection, then let's
+      // try and correct the offset node.
+      const sibling = startNode.getNextSibling();
+      if (start !== end && startOffset === startNode.getTextContentSize() && lexical.$isTextNode(sibling)) {
+        startOffset = 0;
+        startKey = sibling.__key;
+      }
+    } else if (startOffsetNode.type === 'inline') {
+      startKey = startNode.getParentOrThrow().getKey();
+      startOffset = end > startOffsetNode.start ? startOffsetNode.end : startOffsetNode.start;
+    }
+    if (endOffsetNode.type === 'text') {
+      endOffset = end - endOffsetNode.start;
+      endType = 'text';
+    } else if (endOffsetNode.type === 'inline') {
+      endKey = endNode.getParentOrThrow().getKey();
+      endOffset = end > endOffsetNode.start ? endOffsetNode.end : endOffsetNode.start;
+    }
+    const selection = lexical.$createRangeSelection();
+    if (selection === null) {
+      return null;
+    }
+    selection.anchor.set(startKey, startOffset, startType);
+    selection.focus.set(endKey, endOffset, endType);
+    return selection;
+  }
+  getOffsetsFromSelection(selection) {
+    const anchor = selection.anchor;
+    const focus = selection.focus;
+    const offsetMap = this._offsetMap;
+    const anchorOffset = anchor.offset;
+    const focusOffset = focus.offset;
+    let start = -1;
+    let end = -1;
+    if (anchor.type === 'text') {
+      const offsetNode = offsetMap.get(anchor.key);
+      if (offsetNode !== undefined) {
+        start = offsetNode.start + anchorOffset;
+      }
+    } else {
+      const node = anchor.getNode().getDescendantByIndex(anchorOffset);
+      if (node !== null) {
+        const offsetNode = offsetMap.get(node.getKey());
+        if (offsetNode !== undefined) {
+          const isAtEnd = node.getIndexWithinParent() !== anchorOffset;
+          start = isAtEnd ? offsetNode.end : offsetNode.start;
+        }
+      }
+    }
+    if (focus.type === 'text') {
+      const offsetNode = offsetMap.get(focus.key);
+      if (offsetNode !== undefined) {
+        end = offsetNode.start + focus.offset;
+      }
+    } else {
+      const node = focus.getNode().getDescendantByIndex(focusOffset);
+      if (node !== null) {
+        const offsetNode = offsetMap.get(node.getKey());
+        if (offsetNode !== undefined) {
+          const isAtEnd = node.getIndexWithinParent() !== focusOffset;
+          end = isAtEnd ? offsetNode.end : offsetNode.start;
+        }
+      }
+    }
+    return [start, end];
+  }
+}
+function $getAdjustedOffsetFromDiff(offset, offsetNode, prevOffsetView, offsetView, blockOffsetSize) {
+  const prevOffsetMap = prevOffsetView._offsetMap;
+  const offsetMap = offsetView._offsetMap;
+  const visited = new Set();
+  let adjustedOffset = offset;
+  let currentNode = offsetNode;
+  while (currentNode !== null) {
+    const key = currentNode.key;
+    const prevNode = prevOffsetMap.get(key);
+    const diff = currentNode.end - currentNode.start;
+    visited.add(key);
+    if (prevNode === undefined) {
+      adjustedOffset += diff;
+    } else {
+      const prevDiff = prevNode.end - prevNode.start;
+      if (prevDiff !== diff) {
+        adjustedOffset += diff - prevDiff;
+      }
+    }
+    const sibling = currentNode.prev;
+    if (sibling !== null) {
+      currentNode = sibling;
+      continue;
+    }
+    let parent = currentNode.parent;
+    while (parent !== null) {
+      let parentSibling = parent.prev;
+      if (parentSibling !== null) {
+        const parentSiblingKey = parentSibling.key;
+        const prevParentSibling = prevOffsetMap.get(parentSiblingKey);
+        const parentDiff = parentSibling.end - parentSibling.start;
+        visited.add(parentSiblingKey);
+        if (prevParentSibling === undefined) {
+          adjustedOffset += parentDiff;
+        } else {
+          const prevParentDiff = prevParentSibling.end - prevParentSibling.start;
+          if (prevParentDiff !== parentDiff) {
+            adjustedOffset += parentDiff - prevParentDiff;
+          }
+        }
+        parentSibling = parentSibling.prev;
+      }
+      parent = parent.parent;
+    }
+    break;
+  }
+
+  // Now traverse through the old offsets nodes and find any nodes we missed
+  // above, because they were not in the latest offset node view (they have been
+  // deleted).
+  const prevFirstNode = prevOffsetView._firstNode;
+  if (prevFirstNode !== null) {
+    currentNode = $searchForNodeWithOffset(prevFirstNode, offset, blockOffsetSize);
+    let alreadyVisitedParentOfCurrentNode = false;
+    while (currentNode !== null) {
+      if (!visited.has(currentNode.key)) {
+        alreadyVisitedParentOfCurrentNode = true;
+        break;
+      }
+      currentNode = currentNode.parent;
+    }
+    if (!alreadyVisitedParentOfCurrentNode) {
+      while (currentNode !== null) {
+        const key = currentNode.key;
+        if (!visited.has(key)) {
+          const node = offsetMap.get(key);
+          const prevDiff = currentNode.end - currentNode.start;
+          if (node === undefined) {
+            adjustedOffset -= prevDiff;
+          } else {
+            const diff = node.end - node.start;
+            if (prevDiff !== diff) {
+              adjustedOffset += diff - prevDiff;
+            }
+          }
+        }
+        currentNode = currentNode.prev;
+      }
+    }
+  }
+  return adjustedOffset;
+}
+function $searchForNodeWithOffset(firstNode, offset, blockOffsetSize) {
+  let currentNode = firstNode;
+  while (currentNode !== null) {
+    const end = currentNode.end + (currentNode.type !== 'element' || blockOffsetSize === 0 ? 1 : 0);
+    if (offset < end) {
+      const child = currentNode.child;
+      if (child !== null) {
+        currentNode = child;
+        continue;
+      }
+      return currentNode;
+    }
+    const sibling = currentNode.next;
+    if (sibling === null) {
+      break;
+    }
+    currentNode = sibling;
+  }
+  return null;
+}
+function $createInternalOffsetNode(child, type, start, end, key, parent) {
+  return {
+    child,
+    end,
+    key,
+    next: null,
+    parent,
+    prev: null,
+    start,
+    type
+  };
+}
+function $createOffsetNode(state, key, parent, nodeMap, offsetMap, blockOffsetSize) {
+  const node = nodeMap.get(key);
+  if (node === undefined) {
+    {
+      formatDevErrorMessage(`createOffsetModel: could not find node by key`);
+    }
+  }
+  const start = state.offset;
+  if (lexical.$isElementNode(node)) {
+    const childKeys = $createChildrenArray(node, nodeMap);
+    const blockIsEmpty = childKeys.length === 0;
+    const child = blockIsEmpty ? null : $createOffsetChild(state, childKeys, null, nodeMap, offsetMap, blockOffsetSize);
+
+    // If the prev node was not a block or the block is empty, we should
+    // account for the user being able to selection the block (due to the \n).
+    if (!state.prevIsBlock || blockIsEmpty) {
+      state.prevIsBlock = true;
+      state.offset += blockOffsetSize;
+    }
+    const offsetNode = $createInternalOffsetNode(child, 'element', start, start, key, parent);
+    if (child !== null) {
+      child.parent = offsetNode;
+    }
+    const end = state.offset;
+    offsetNode.end = end;
+    offsetMap.set(key, offsetNode);
+    return offsetNode;
+  }
+  state.prevIsBlock = false;
+  const isText = lexical.$isTextNode(node);
+  const length = isText ? node.__text.length : 1;
+  const end = state.offset += length;
+  const offsetNode = $createInternalOffsetNode(null, isText ? 'text' : 'inline', start, end, key, parent);
+  offsetMap.set(key, offsetNode);
+  return offsetNode;
+}
+function $createOffsetChild(state, children, parent, nodeMap, offsetMap, blockOffsetSize) {
+  let firstNode = null;
+  let currentNode = null;
+  const childrenLength = children.length;
+  for (let i = 0; i < childrenLength; i++) {
+    const childKey = children[i];
+    const offsetNode = $createOffsetNode(state, childKey, parent, nodeMap, offsetMap, blockOffsetSize);
+    if (currentNode === null) {
+      firstNode = offsetNode;
+    } else {
+      offsetNode.prev = currentNode;
+      currentNode.next = offsetNode;
+    }
+    currentNode = offsetNode;
+  }
+  return firstNode;
+}
+function $createChildrenArray(element, nodeMap) {
+  const children = [];
+  let nodeKey = element.__first;
+  while (nodeKey !== null) {
+    const node = nodeMap === null ? lexical.$getNodeByKey(nodeKey) : nodeMap.get(nodeKey);
+    if (node === null || node === undefined) {
+      {
+        formatDevErrorMessage(`$createChildrenArray: node does not exist in nodeMap`);
+      }
+    }
+    children.push(nodeKey);
+    nodeKey = node.__next;
+  }
+  return children;
+}
+/** @deprecated renamed to {@link $createChildrenArray} by @ekz/lexical-eslint-plugin rules-of-lexical */
+const createChildrenArray = $createChildrenArray;
+function $createOffsetView(editor, blockOffsetSize = 1, editorState) {
+  const targetEditorState = editorState || editor._pendingEditorState || editor._editorState;
+  const nodeMap = targetEditorState._nodeMap;
+  const root = nodeMap.get('root');
+  const offsetMap = new Map();
+  const state = {
+    offset: 0,
+    prevIsBlock: false
+  };
+  const node = $createOffsetChild(state, $createChildrenArray(root, nodeMap), null, nodeMap, offsetMap, blockOffsetSize);
+  return new OffsetView(offsetMap, node, blockOffsetSize);
+}
+
+exports.$createChildrenArray = $createChildrenArray;
+exports.$createOffsetView = $createOffsetView;
+exports.OffsetView = OffsetView;
+exports.createChildrenArray = createChildrenArray;

package/EkzLexicalOffset.dev.mjs

@@ -0,0 +1,331 @@
+/**
+ * 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.
+ *
+ */
+
+import { $getNodeByKey, $isTextNode, $createRangeSelection, $isElementNode } from '@ekz/lexical';
+
+/**
+ * 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.
+ *
+ */
+
+// Do not require this module directly! Use normal `invariant` calls.
+
+function formatDevErrorMessage(message) {
+  throw new Error(message);
+}
+
+class OffsetView {
+  _offsetMap;
+  _firstNode;
+  _blockOffsetSize;
+  constructor(offsetMap, firstNode, blockOffsetSize = 1) {
+    this._offsetMap = offsetMap;
+    this._firstNode = firstNode;
+    this._blockOffsetSize = blockOffsetSize;
+  }
+  createSelectionFromOffsets(originalStart, originalEnd, diffOffsetView) {
+    const firstNode = this._firstNode;
+    if (firstNode === null) {
+      return null;
+    }
+    let start = originalStart;
+    let end = originalEnd;
+    let startOffsetNode = $searchForNodeWithOffset(firstNode, start, this._blockOffsetSize);
+    let endOffsetNode = $searchForNodeWithOffset(firstNode, end, this._blockOffsetSize);
+    if (diffOffsetView !== undefined) {
+      start = $getAdjustedOffsetFromDiff(start, startOffsetNode, diffOffsetView, this, this._blockOffsetSize);
+      startOffsetNode = $searchForNodeWithOffset(firstNode, start, this._blockOffsetSize);
+      end = $getAdjustedOffsetFromDiff(end, endOffsetNode, diffOffsetView, this, this._blockOffsetSize);
+      endOffsetNode = $searchForNodeWithOffset(firstNode, end, this._blockOffsetSize);
+    }
+    if (startOffsetNode === null || endOffsetNode === null) {
+      return null;
+    }
+    let startKey = startOffsetNode.key;
+    let endKey = endOffsetNode.key;
+    const startNode = $getNodeByKey(startKey);
+    const endNode = $getNodeByKey(endKey);
+    if (startNode === null || endNode === null) {
+      return null;
+    }
+    let startOffset = 0;
+    let endOffset = 0;
+    let startType = 'element';
+    let endType = 'element';
+    if (startOffsetNode.type === 'text') {
+      startOffset = start - startOffsetNode.start;
+      startType = 'text';
+      // If we are at the edge of a text node and we
+      // don't have a collapsed selection, then let's
+      // try and correct the offset node.
+      const sibling = startNode.getNextSibling();
+      if (start !== end && startOffset === startNode.getTextContentSize() && $isTextNode(sibling)) {
+        startOffset = 0;
+        startKey = sibling.__key;
+      }
+    } else if (startOffsetNode.type === 'inline') {
+      startKey = startNode.getParentOrThrow().getKey();
+      startOffset = end > startOffsetNode.start ? startOffsetNode.end : startOffsetNode.start;
+    }
+    if (endOffsetNode.type === 'text') {
+      endOffset = end - endOffsetNode.start;
+      endType = 'text';
+    } else if (endOffsetNode.type === 'inline') {
+      endKey = endNode.getParentOrThrow().getKey();
+      endOffset = end > endOffsetNode.start ? endOffsetNode.end : endOffsetNode.start;
+    }
+    const selection = $createRangeSelection();
+    if (selection === null) {
+      return null;
+    }
+    selection.anchor.set(startKey, startOffset, startType);
+    selection.focus.set(endKey, endOffset, endType);
+    return selection;
+  }
+  getOffsetsFromSelection(selection) {
+    const anchor = selection.anchor;
+    const focus = selection.focus;
+    const offsetMap = this._offsetMap;
+    const anchorOffset = anchor.offset;
+    const focusOffset = focus.offset;
+    let start = -1;
+    let end = -1;
+    if (anchor.type === 'text') {
+      const offsetNode = offsetMap.get(anchor.key);
+      if (offsetNode !== undefined) {
+        start = offsetNode.start + anchorOffset;
+      }
+    } else {
+      const node = anchor.getNode().getDescendantByIndex(anchorOffset);
+      if (node !== null) {
+        const offsetNode = offsetMap.get(node.getKey());
+        if (offsetNode !== undefined) {
+          const isAtEnd = node.getIndexWithinParent() !== anchorOffset;
+          start = isAtEnd ? offsetNode.end : offsetNode.start;
+        }
+      }
+    }
+    if (focus.type === 'text') {
+      const offsetNode = offsetMap.get(focus.key);
+      if (offsetNode !== undefined) {
+        end = offsetNode.start + focus.offset;
+      }
+    } else {
+      const node = focus.getNode().getDescendantByIndex(focusOffset);
+      if (node !== null) {
+        const offsetNode = offsetMap.get(node.getKey());
+        if (offsetNode !== undefined) {
+          const isAtEnd = node.getIndexWithinParent() !== focusOffset;
+          end = isAtEnd ? offsetNode.end : offsetNode.start;
+        }
+      }
+    }
+    return [start, end];
+  }
+}
+function $getAdjustedOffsetFromDiff(offset, offsetNode, prevOffsetView, offsetView, blockOffsetSize) {
+  const prevOffsetMap = prevOffsetView._offsetMap;
+  const offsetMap = offsetView._offsetMap;
+  const visited = new Set();
+  let adjustedOffset = offset;
+  let currentNode = offsetNode;
+  while (currentNode !== null) {
+    const key = currentNode.key;
+    const prevNode = prevOffsetMap.get(key);
+    const diff = currentNode.end - currentNode.start;
+    visited.add(key);
+    if (prevNode === undefined) {
+      adjustedOffset += diff;
+    } else {
+      const prevDiff = prevNode.end - prevNode.start;
+      if (prevDiff !== diff) {
+        adjustedOffset += diff - prevDiff;
+      }
+    }
+    const sibling = currentNode.prev;
+    if (sibling !== null) {
+      currentNode = sibling;
+      continue;
+    }
+    let parent = currentNode.parent;
+    while (parent !== null) {
+      let parentSibling = parent.prev;
+      if (parentSibling !== null) {
+        const parentSiblingKey = parentSibling.key;
+        const prevParentSibling = prevOffsetMap.get(parentSiblingKey);
+        const parentDiff = parentSibling.end - parentSibling.start;
+        visited.add(parentSiblingKey);
+        if (prevParentSibling === undefined) {
+          adjustedOffset += parentDiff;
+        } else {
+          const prevParentDiff = prevParentSibling.end - prevParentSibling.start;
+          if (prevParentDiff !== parentDiff) {
+            adjustedOffset += parentDiff - prevParentDiff;
+          }
+        }
+        parentSibling = parentSibling.prev;
+      }
+      parent = parent.parent;
+    }
+    break;
+  }
+
+  // Now traverse through the old offsets nodes and find any nodes we missed
+  // above, because they were not in the latest offset node view (they have been
+  // deleted).
+  const prevFirstNode = prevOffsetView._firstNode;
+  if (prevFirstNode !== null) {
+    currentNode = $searchForNodeWithOffset(prevFirstNode, offset, blockOffsetSize);
+    let alreadyVisitedParentOfCurrentNode = false;
+    while (currentNode !== null) {
+      if (!visited.has(currentNode.key)) {
+        alreadyVisitedParentOfCurrentNode = true;
+        break;
+      }
+      currentNode = currentNode.parent;
+    }
+    if (!alreadyVisitedParentOfCurrentNode) {
+      while (currentNode !== null) {
+        const key = currentNode.key;
+        if (!visited.has(key)) {
+          const node = offsetMap.get(key);
+          const prevDiff = currentNode.end - currentNode.start;
+          if (node === undefined) {
+            adjustedOffset -= prevDiff;
+          } else {
+            const diff = node.end - node.start;
+            if (prevDiff !== diff) {
+              adjustedOffset += diff - prevDiff;
+            }
+          }
+        }
+        currentNode = currentNode.prev;
+      }
+    }
+  }
+  return adjustedOffset;
+}
+function $searchForNodeWithOffset(firstNode, offset, blockOffsetSize) {
+  let currentNode = firstNode;
+  while (currentNode !== null) {
+    const end = currentNode.end + (currentNode.type !== 'element' || blockOffsetSize === 0 ? 1 : 0);
+    if (offset < end) {
+      const child = currentNode.child;
+      if (child !== null) {
+        currentNode = child;
+        continue;
+      }
+      return currentNode;
+    }
+    const sibling = currentNode.next;
+    if (sibling === null) {
+      break;
+    }
+    currentNode = sibling;
+  }
+  return null;
+}
+function $createInternalOffsetNode(child, type, start, end, key, parent) {
+  return {
+    child,
+    end,
+    key,
+    next: null,
+    parent,
+    prev: null,
+    start,
+    type
+  };
+}
+function $createOffsetNode(state, key, parent, nodeMap, offsetMap, blockOffsetSize) {
+  const node = nodeMap.get(key);
+  if (node === undefined) {
+    {
+      formatDevErrorMessage(`createOffsetModel: could not find node by key`);
+    }
+  }
+  const start = state.offset;
+  if ($isElementNode(node)) {
+    const childKeys = $createChildrenArray(node, nodeMap);
+    const blockIsEmpty = childKeys.length === 0;
+    const child = blockIsEmpty ? null : $createOffsetChild(state, childKeys, null, nodeMap, offsetMap, blockOffsetSize);
+
+    // If the prev node was not a block or the block is empty, we should
+    // account for the user being able to selection the block (due to the \n).
+    if (!state.prevIsBlock || blockIsEmpty) {
+      state.prevIsBlock = true;
+      state.offset += blockOffsetSize;
+    }
+    const offsetNode = $createInternalOffsetNode(child, 'element', start, start, key, parent);
+    if (child !== null) {
+      child.parent = offsetNode;
+    }
+    const end = state.offset;
+    offsetNode.end = end;
+    offsetMap.set(key, offsetNode);
+    return offsetNode;
+  }
+  state.prevIsBlock = false;
+  const isText = $isTextNode(node);
+  const length = isText ? node.__text.length : 1;
+  const end = state.offset += length;
+  const offsetNode = $createInternalOffsetNode(null, isText ? 'text' : 'inline', start, end, key, parent);
+  offsetMap.set(key, offsetNode);
+  return offsetNode;
+}
+function $createOffsetChild(state, children, parent, nodeMap, offsetMap, blockOffsetSize) {
+  let firstNode = null;
+  let currentNode = null;
+  const childrenLength = children.length;
+  for (let i = 0; i < childrenLength; i++) {
+    const childKey = children[i];
+    const offsetNode = $createOffsetNode(state, childKey, parent, nodeMap, offsetMap, blockOffsetSize);
+    if (currentNode === null) {
+      firstNode = offsetNode;
+    } else {
+      offsetNode.prev = currentNode;
+      currentNode.next = offsetNode;
+    }
+    currentNode = offsetNode;
+  }
+  return firstNode;
+}
+function $createChildrenArray(element, nodeMap) {
+  const children = [];
+  let nodeKey = element.__first;
+  while (nodeKey !== null) {
+    const node = nodeMap === null ? $getNodeByKey(nodeKey) : nodeMap.get(nodeKey);
+    if (node === null || node === undefined) {
+      {
+        formatDevErrorMessage(`$createChildrenArray: node does not exist in nodeMap`);
+      }
+    }
+    children.push(nodeKey);
+    nodeKey = node.__next;
+  }
+  return children;
+}
+/** @deprecated renamed to {@link $createChildrenArray} by @ekz/lexical-eslint-plugin rules-of-lexical */
+const createChildrenArray = $createChildrenArray;
+function $createOffsetView(editor, blockOffsetSize = 1, editorState) {
+  const targetEditorState = editorState || editor._pendingEditorState || editor._editorState;
+  const nodeMap = targetEditorState._nodeMap;
+  const root = nodeMap.get('root');
+  const offsetMap = new Map();
+  const state = {
+    offset: 0,
+    prevIsBlock: false
+  };
+  const node = $createOffsetChild(state, $createChildrenArray(root, nodeMap), null, nodeMap, offsetMap, blockOffsetSize);
+  return new OffsetView(offsetMap, node, blockOffsetSize);
+}
+
+export { $createChildrenArray, $createOffsetView, OffsetView, createChildrenArray };

package/EkzLexicalOffset.js

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ */
+
+'use strict'
+const EkzLexicalOffset = process.env.NODE_ENV !== 'production' ? require('./EkzLexicalOffset.dev.js') : require('./EkzLexicalOffset.prod.js');
+module.exports = EkzLexicalOffset;

package/EkzLexicalOffset.mjs

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ *
+ */
+
+import * as modDev from './EkzLexicalOffset.dev.mjs';
+import * as modProd from './EkzLexicalOffset.prod.mjs';
+const mod = process.env.NODE_ENV !== 'production' ? modDev : modProd;
+export const $createChildrenArray = mod.$createChildrenArray;
+export const $createOffsetView = mod.$createOffsetView;
+export const OffsetView = mod.OffsetView;
+export const createChildrenArray = mod.createChildrenArray;

package/EkzLexicalOffset.node.mjs

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV !== 'production' ? import('./EkzLexicalOffset.dev.mjs') : import('./EkzLexicalOffset.prod.mjs'));
+export const $createChildrenArray = mod.$createChildrenArray;
+export const $createOffsetView = mod.$createOffsetView;
+export const OffsetView = mod.OffsetView;
+export const createChildrenArray = mod.createChildrenArray;

package/EkzLexicalOffset.prod.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ */
+
+"use strict";var e=require("@ekz/lexical");function t(e,...t){const n=new URL("https://lexical.dev/docs/error"),s=new URLSearchParams;s.append("code",e);for(const e of t)s.append("v",e);throw n.search=s.toString(),Error(`Minified Lexical error #${e}; visit ${n.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`)}class n{_offsetMap;_firstNode;_blockOffsetSize;constructor(e,t,n=1){this._offsetMap=e,this._firstNode=t,this._blockOffsetSize=n}createSelectionFromOffsets(t,n,r){const l=this._firstNode;if(null===l)return null;let i=t,f=n,c=o(l,i,this._blockOffsetSize),a=o(l,f,this._blockOffsetSize);if(void 0!==r&&(i=s(i,c,r,this,this._blockOffsetSize),c=o(l,i,this._blockOffsetSize),f=s(f,a,r,this,this._blockOffsetSize),a=o(l,f,this._blockOffsetSize)),null===c||null===a)return null;let u=c.key,d=a.key;const p=e.$getNodeByKey(u),g=e.$getNodeByKey(d);if(null===p||null===g)return null;let h=0,y=0,_="element",x="element";if("text"===c.type){h=i-c.start,_="text";const t=p.getNextSibling();i!==f&&h===p.getTextContentSize()&&e.$isTextNode(t)&&(h=0,u=t.__key)}else"inline"===c.type&&(u=p.getParentOrThrow().getKey(),h=f>c.start?c.end:c.start);"text"===a.type?(y=f-a.start,x="text"):"inline"===a.type&&(d=g.getParentOrThrow().getKey(),y=f>a.start?a.end:a.start);const k=e.$createRangeSelection();return null===k?null:(k.anchor.set(u,h,_),k.focus.set(d,y,x),k)}getOffsetsFromSelection(e){const t=e.anchor,n=e.focus,s=this._offsetMap,o=t.offset,r=n.offset;let l=-1,i=-1;if("text"===t.type){const e=s.get(t.key);void 0!==e&&(l=e.start+o)}else{const e=t.getNode().getDescendantByIndex(o);if(null!==e){const t=s.get(e.getKey());if(void 0!==t){l=e.getIndexWithinParent()!==o?t.end:t.start}}}if("text"===n.type){const e=s.get(n.key);void 0!==e&&(i=e.start+n.offset)}else{const e=n.getNode().getDescendantByIndex(r);if(null!==e){const t=s.get(e.getKey());if(void 0!==t){i=e.getIndexWithinParent()!==r?t.end:t.start}}}return[l,i]}}function s(e,t,n,s,r){const l=n._offsetMap,i=s._offsetMap,f=new Set;let c=e,a=t;for(;null!==a;){const e=a.key,t=l.get(e),n=a.end-a.start;if(f.add(e),void 0===t)c+=n;else{const e=t.end-t.start;e!==n&&(c+=n-e)}const s=a.prev;if(null!==s){a=s;continue}let o=a.parent;for(;null!==o;){let e=o.prev;if(null!==e){const t=e.key,n=l.get(t),s=e.end-e.start;if(f.add(t),void 0===n)c+=s;else{const e=n.end-n.start;e!==s&&(c+=s-e)}e=e.prev}o=o.parent}break}const u=n._firstNode;if(null!==u){a=o(u,e,r);let t=!1;for(;null!==a;){if(!f.has(a.key)){t=!0;break}a=a.parent}if(!t)for(;null!==a;){const e=a.key;if(!f.has(e)){const t=i.get(e),n=a.end-a.start;if(void 0===t)c-=n;else{const e=t.end-t.start;n!==e&&(c+=e-n)}}a=a.prev}}return c}function o(e,t,n){let s=e;for(;null!==s;){if(t<s.end+("element"!==s.type||0===n?1:0)){const e=s.child;if(null!==e){s=e;continue}return s}const e=s.next;if(null===e)break;s=e}return null}function r(e,t,n,s,o,r){return{child:e,end:s,key:o,next:null,parent:r,prev:null,start:n,type:t}}function l(n,s,o,l,c,a){const u=l.get(s);void 0===u&&t(3);const d=n.offset;if(e.$isElementNode(u)){const e=f(u,l),t=0===e.length,p=t?null:i(n,e,null,l,c,a);n.prevIsBlock&&!t||(n.prevIsBlock=!0,n.offset+=a);const g=r(p,"element",d,d,s,o);null!==p&&(p.parent=g);const h=n.offset;return g.end=h,c.set(s,g),g}n.prevIsBlock=!1;const p=e.$isTextNode(u),g=p?u.__text.length:1,h=r(null,p?"text":"inline",d,n.offset+=g,s,o);return c.set(s,h),h}function i(e,t,n,s,o,r){let i=null,f=null;const c=t.length;for(let a=0;a<c;a++){const c=l(e,t[a],n,s,o,r);null===f?i=c:(c.prev=f,f.next=c),f=c}return i}function f(n,s){const o=[];let r=n.__first;for(;null!==r;){const n=null===s?e.$getNodeByKey(r):s.get(r);null==n&&t(174),o.push(r),r=n.__next}return o}const c=f;exports.$createChildrenArray=f,exports.$createOffsetView=function(e,t=1,s){const o=(s||e._pendingEditorState||e._editorState)._nodeMap,r=o.get("root"),l=new Map,c=i({offset:0,prevIsBlock:!1},f(r,o),null,o,l,t);return new n(l,c,t)},exports.OffsetView=n,exports.createChildrenArray=c;

package/EkzLexicalOffset.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ */
+
+import{$getNodeByKey as t,$isTextNode as e,$createRangeSelection as n,$isElementNode as o}from"@ekz/lexical";function s(t,...e){const n=new URL("https://lexical.dev/docs/error"),o=new URLSearchParams;o.append("code",t);for(const t of e)o.append("v",t);throw n.search=o.toString(),Error(`Minified Lexical error #${t}; visit ${n.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`)}class l{_offsetMap;_firstNode;_blockOffsetSize;constructor(t,e,n=1){this._offsetMap=t,this._firstNode=e,this._blockOffsetSize=n}createSelectionFromOffsets(o,s,l){const f=this._firstNode;if(null===f)return null;let c=o,u=s,a=i(f,c,this._blockOffsetSize),d=i(f,u,this._blockOffsetSize);if(void 0!==l&&(c=r(c,a,l,this,this._blockOffsetSize),a=i(f,c,this._blockOffsetSize),u=r(u,d,l,this,this._blockOffsetSize),d=i(f,u,this._blockOffsetSize)),null===a||null===d)return null;let p=a.key,g=d.key;const h=t(p),_=t(g);if(null===h||null===_)return null;let k=0,v=0,y="element",x="element";if("text"===a.type){k=c-a.start,y="text";const t=h.getNextSibling();c!==u&&k===h.getTextContentSize()&&e(t)&&(k=0,p=t.__key)}else"inline"===a.type&&(p=h.getParentOrThrow().getKey(),k=u>a.start?a.end:a.start);"text"===d.type?(v=u-d.start,x="text"):"inline"===d.type&&(g=_.getParentOrThrow().getKey(),v=u>d.start?d.end:d.start);const S=n();return null===S?null:(S.anchor.set(p,k,y),S.focus.set(g,v,x),S)}getOffsetsFromSelection(t){const e=t.anchor,n=t.focus,o=this._offsetMap,s=e.offset,l=n.offset;let r=-1,i=-1;if("text"===e.type){const t=o.get(e.key);void 0!==t&&(r=t.start+s)}else{const t=e.getNode().getDescendantByIndex(s);if(null!==t){const e=o.get(t.getKey());if(void 0!==e){r=t.getIndexWithinParent()!==s?e.end:e.start}}}if("text"===n.type){const t=o.get(n.key);void 0!==t&&(i=t.start+n.offset)}else{const t=n.getNode().getDescendantByIndex(l);if(null!==t){const e=o.get(t.getKey());if(void 0!==e){i=t.getIndexWithinParent()!==l?e.end:e.start}}}return[r,i]}}function r(t,e,n,o,s){const l=n._offsetMap,r=o._offsetMap,f=new Set;let c=t,u=e;for(;null!==u;){const t=u.key,e=l.get(t),n=u.end-u.start;if(f.add(t),void 0===e)c+=n;else{const t=e.end-e.start;t!==n&&(c+=n-t)}const o=u.prev;if(null!==o){u=o;continue}let s=u.parent;for(;null!==s;){let t=s.prev;if(null!==t){const e=t.key,n=l.get(e),o=t.end-t.start;if(f.add(e),void 0===n)c+=o;else{const t=n.end-n.start;t!==o&&(c+=o-t)}t=t.prev}s=s.parent}break}const a=n._firstNode;if(null!==a){u=i(a,t,s);let e=!1;for(;null!==u;){if(!f.has(u.key)){e=!0;break}u=u.parent}if(!e)for(;null!==u;){const t=u.key;if(!f.has(t)){const e=r.get(t),n=u.end-u.start;if(void 0===e)c-=n;else{const t=e.end-e.start;n!==t&&(c+=t-n)}}u=u.prev}}return c}function i(t,e,n){let o=t;for(;null!==o;){if(e<o.end+("element"!==o.type||0===n?1:0)){const t=o.child;if(null!==t){o=t;continue}return o}const t=o.next;if(null===t)break;o=t}return null}function f(t,e,n,o,s,l){return{child:t,end:o,key:s,next:null,parent:l,prev:null,start:n,type:e}}function c(t,n,l,r,i,c){const d=r.get(n);void 0===d&&s(3);const p=t.offset;if(o(d)){const e=a(d,r),o=0===e.length,s=o?null:u(t,e,null,r,i,c);t.prevIsBlock&&!o||(t.prevIsBlock=!0,t.offset+=c);const g=f(s,"element",p,p,n,l);null!==s&&(s.parent=g);const h=t.offset;return g.end=h,i.set(n,g),g}t.prevIsBlock=!1;const g=e(d),h=g?d.__text.length:1,_=f(null,g?"text":"inline",p,t.offset+=h,n,l);return i.set(n,_),_}function u(t,e,n,o,s,l){let r=null,i=null;const f=e.length;for(let u=0;u<f;u++){const f=c(t,e[u],n,o,s,l);null===i?r=f:(f.prev=i,i.next=f),i=f}return r}function a(e,n){const o=[];let l=e.__first;for(;null!==l;){const e=null===n?t(l):n.get(l);null==e&&s(174),o.push(l),l=e.__next}return o}const d=a;function p(t,e=1,n){const o=(n||t._pendingEditorState||t._editorState)._nodeMap,s=o.get("root"),r=new Map,i=u({offset:0,prevIsBlock:!1},a(s,o),null,o,r,e);return new l(r,i,e)}export{a as $createChildrenArray,p as $createOffsetView,l as OffsetView,d as createChildrenArray};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LexicalOffset.js.flow

@@ -0,0 +1,67 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+import type {
+  EditorState,
+  LexicalEditor,
+  NodeKey,
+  RangeSelection,
+} from '@ekz/lexical';
+type OffsetElementNode = {
+  child: null | OffsetNode,
+  end: number,
+  key: NodeKey,
+  next: null | OffsetNode,
+  parent: null | OffsetElementNode,
+  prev: null | OffsetNode,
+  start: number,
+  type: 'element',
+};
+type OffsetTextNode = {
+  child: null,
+  end: number,
+  key: NodeKey,
+  next: null | OffsetNode,
+  parent: null | OffsetElementNode,
+  prev: null | OffsetNode,
+  start: number,
+  type: 'text',
+};
+type OffsetInlineNode = {
+  child: null,
+  end: number,
+  key: NodeKey,
+  next: null | OffsetNode,
+  parent: null | OffsetElementNode,
+  prev: null | OffsetNode,
+  start: number,
+  type: 'inline',
+};
+type OffsetNode = OffsetElementNode | OffsetTextNode | OffsetInlineNode;
+type OffsetMap = Map<NodeKey, OffsetNode>;
+declare export class OffsetView {
+  _offsetMap: OffsetMap;
+  _firstNode: null | OffsetNode;
+  _blockOffsetSize: number;
+  constructor(
+    offsetMap: OffsetMap,
+    firstNode: null | OffsetNode,
+    blockOffsetSize: number,
+  ): void;
+  createSelectionFromOffsets(
+    originalStart: number,
+    originalEnd: number,
+    diffOffsetView?: OffsetView,
+  ): null | RangeSelection;
+  getOffsetsFromSelection(selection: RangeSelection): [number, number];
+}
+declare export function $createOffsetView(
+  editor: LexicalEditor,
+  blockOffsetSize?: number,
+  editorState?: EditorState,
+): OffsetView;

package/README.md

@@ -0,0 +1,5 @@
+# `@lexical/offset`
+
+[![See API Documentation](https://lexical.dev/img/see-api-documentation.svg)](https://lexical.dev/docs/api/modules/lexical_offset)
+
+This package contains selection offset helpers for Lexical.

package/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ *
+ */
+import type { EditorState, ElementNode, LexicalEditor, NodeKey, NodeMap, RangeSelection } from '@ekz/lexical';
+type OffsetElementNode = {
+    child: null | OffsetNode;
+    end: number;
+    key: NodeKey;
+    next: null | OffsetNode;
+    parent: null | OffsetElementNode;
+    prev: null | OffsetNode;
+    start: number;
+    type: 'element';
+};
+type OffsetTextNode = {
+    child: null;
+    end: number;
+    key: NodeKey;
+    next: null | OffsetNode;
+    parent: null | OffsetElementNode;
+    prev: null | OffsetNode;
+    start: number;
+    type: 'text';
+};
+type OffsetInlineNode = {
+    child: null;
+    end: number;
+    key: NodeKey;
+    next: null | OffsetNode;
+    parent: null | OffsetElementNode;
+    prev: null | OffsetNode;
+    start: number;
+    type: 'inline';
+};
+type OffsetNode = OffsetElementNode | OffsetTextNode | OffsetInlineNode;
+type OffsetMap = Map<NodeKey, OffsetNode>;
+export declare class OffsetView {
+    _offsetMap: OffsetMap;
+    _firstNode: null | OffsetNode;
+    _blockOffsetSize: number;
+    constructor(offsetMap: OffsetMap, firstNode: null | OffsetNode, blockOffsetSize?: number);
+    createSelectionFromOffsets(originalStart: number, originalEnd: number, diffOffsetView?: OffsetView): null | RangeSelection;
+    getOffsetsFromSelection(selection: RangeSelection): [number, number];
+}
+export declare function $createChildrenArray(element: ElementNode, nodeMap: null | NodeMap): Array<NodeKey>;
+/** @deprecated renamed to {@link $createChildrenArray} by @ekz/lexical-eslint-plugin rules-of-lexical */
+export declare const createChildrenArray: typeof $createChildrenArray;
+export declare function $createOffsetView(editor: LexicalEditor, blockOffsetSize?: number, editorState?: EditorState | null): OffsetView;
+export {};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ekz/lexical-offset",
+  "description": "This package contains selection offset helpers for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "offset"
+  ],
+  "license": "MIT",
+  "version": "0.40.0",
+  "main": "LexicalOffset.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/lexical.git",
+    "directory": "packages/lexical-offset"
+  },
+  "module": "LexicalOffset.mjs",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "development": "./LexicalOffset.dev.mjs",
+        "production": "./LexicalOffset.prod.mjs",
+        "node": "./LexicalOffset.node.mjs",
+        "default": "./LexicalOffset.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "development": "./LexicalOffset.dev.js",
+        "production": "./LexicalOffset.prod.js",
+        "default": "./LexicalOffset.js"
+      }
+    }
+  },
+  "dependencies": {
+    "@ekz/lexical": "0.40.0"
+  }
+}