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

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

@@ -0,0 +1,127 @@
+'use strict';
+
+var React = require('react');
+var reactUtils = require('@udecode/react-utils');
+var clsx_m = require('../../../clsx/dist/clsx.m.js');
+require('../../../lodash/merge.js');
+var index = require('../../plate-core/dist/index.js');
+require('../../../lodash/defaults.js');
+var index$2 = require('../../slate/dist/index.js');
+var index$1 = require('../../slate-react/dist/index.js');
+require('slate-react');
+
+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;
+};
+var usePlateElement = (props) => {
+  const _a = props, {
+    editor,
+    attributes,
+    nodeProps,
+    element,
+    elementToAttributes
+  } = _a, rootProps = __objRest(_a, [
+    "editor",
+    "attributes",
+    "nodeProps",
+    "element",
+    "elementToAttributes"
+  ]);
+  return {
+    ref: reactUtils.useComposedRef(props.ref, attributes.ref),
+    props: __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, attributes), rootProps), nodeProps), elementToAttributes == null ? void 0 : elementToAttributes(element)), {
+      className: clsx_m.clsx(props.className, nodeProps == null ? void 0 : nodeProps.className)
+    })
+  };
+};
+var PlateElement = React__default.default.forwardRef(
+  (props, ref) => {
+    const { ref: rootRef, props: rootProps } = usePlateElement(__spreadProps(__spreadValues({}, props), {
+      ref
+    }));
+    return /* @__PURE__ */ React__default.default.createElement(reactUtils.Box, __spreadProps(__spreadValues({}, rootProps), { ref: rootRef }));
+  }
+);
+PlateElement.displayName = "PlateElement";
+var usePlateLeaf = (props) => {
+  const _a = props, {
+    editor,
+    attributes,
+    nodeProps,
+    text,
+    leaf,
+    leafToAttributes
+  } = _a, rootProps = __objRest(_a, [
+    "editor",
+    "attributes",
+    "nodeProps",
+    "text",
+    "leaf",
+    "leafToAttributes"
+  ]);
+  return {
+    ref: reactUtils.useComposedRef(props.ref, attributes.ref),
+    props: __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, attributes), rootProps), nodeProps), leafToAttributes == null ? void 0 : leafToAttributes(leaf)), {
+      className: clsx_m.clsx(props.className, nodeProps == null ? void 0 : nodeProps.className)
+    })
+  };
+};
+var PlateLeaf = React__default.default.forwardRef(
+  (props, ref) => {
+    const { ref: rootRef, props: rootProps } = usePlateLeaf(__spreadProps(__spreadValues({}, props), { ref }));
+    return /* @__PURE__ */ React__default.default.createElement(reactUtils.Text, __spreadProps(__spreadValues({}, rootProps), { ref: rootRef }));
+  }
+);
+PlateLeaf.displayName = "PlateLeaf";
+var useRemoveNodeButton = ({ element }) => {
+  const editor = index.useEditorRef();
+  return {
+    props: {
+      onMouseDown: (e) => {
+        e.preventDefault();
+      },
+      onClick: () => {
+        const path = index$1.findNodePath(editor, element);
+        index$2.removeNodes(editor, { at: path });
+      }
+    }
+  };
+};
+
+exports.PlateElement = PlateElement;
+exports.PlateLeaf = PlateLeaf;
+exports.usePlateElement = usePlateElement;
+exports.usePlateLeaf = usePlateLeaf;
+exports.useRemoveNodeButton = useRemoveNodeButton;

package/dist/node_modules/@udecode/slate/dist/index.js

@@ -0,0 +1,316 @@
+'use strict';
+
+var slate = require('slate');
+require('slate-history');
+
+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;
+};
+var createTEditor = () => slate.createEditor();
+var isElement = (value) => slate.Element.isElement(value);
+
+// src/interfaces/editor/isBlock.ts
+var isBlock = (editor, value) => isElement(value) && slate.Editor.isBlock(editor, value);
+
+// src/utils/match.ts
+function castArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+var match = (obj, path, predicate) => {
+  if (!predicate)
+    return true;
+  if (typeof predicate === "object") {
+    return Object.entries(predicate).every(([key, value]) => {
+      const values = castArray(value);
+      return values.includes(obj[key]);
+    });
+  }
+  return predicate(obj, path);
+};
+var getQueryOptions = (editor, options = {}) => {
+  const { match: _match, block } = options;
+  return __spreadProps(__spreadValues({}, options), {
+    match: _match || block ? (n, path) => match(n, path, _match) && (!block || isBlock(editor, n)) : void 0
+  });
+};
+
+// src/interfaces/editor/getAboveNode.ts
+var getAboveNode = (editor, options) => slate.Editor.above(editor, getQueryOptions(editor, options));
+var unhangRange = (editor, range, options = {}) => {
+  const { voids, unhang = true } = options;
+  if (slate.Range.isRange(range) && unhang) {
+    return slate.Editor.unhangRange(editor, range, { voids });
+  }
+  return range;
+};
+
+// src/interfaces/editor/getNodeEntries.ts
+var getNodeEntries = (editor, options) => {
+  unhangRange(editor, options == null ? void 0 : options.at, options);
+  return slate.Editor.nodes(editor, getQueryOptions(editor, options));
+};
+var getParentNode = (editor, at, options) => {
+  try {
+    return slate.Editor.parent(editor, at, options);
+  } catch (error) {
+  }
+};
+var getPreviousNode = (editor, options) => slate.Editor.previous(editor, options);
+var isElementEmpty = (editor, element) => slate.Editor.isEmpty(editor, element);
+var withoutNormalizing = (editor, fn) => {
+  let normalized = false;
+  slate.Editor.withoutNormalizing(editor, () => {
+    normalized = !!fn();
+  });
+  return normalized;
+};
+var isText = (value) => slate.Text.isText(value);
+var removeNodes = (editor, options) => slate.Transforms.removeNodes(editor, options);
+var select = (editor, target) => {
+  slate.Transforms.select(editor, target);
+};
+var getEndPoint = (editor, at) => slate.Editor.end(editor, at);
+var getPointBefore = (editor, at, options) => slate.Editor.before(editor, at, options);
+var getStartPoint = (editor, at) => slate.Editor.start(editor, at);
+var getEdgePoints = (editor, at) => slate.Editor.edges(editor, at);
+var getEditorString = (editor, at, options) => {
+  if (!at)
+    return "";
+  try {
+    return slate.Editor.string(editor, at, options);
+  } catch (error) {
+    return "";
+  }
+};
+var getMarks = (editor) => slate.Editor.marks(editor);
+var getNextNode = (editor, options) => slate.Editor.next(editor, options);
+var getNodeEntry = (editor, at, options) => {
+  try {
+    return slate.Editor.node(editor, at, options);
+  } catch (error) {
+  }
+};
+var getPoint = (editor, at, options) => slate.Editor.point(editor, at, options);
+var isEndPoint = (editor, point, at) => !!point && slate.Editor.isEnd(editor, point, at);
+var isInline = (editor, value) => isElement(value) && slate.Editor.isInline(editor, value);
+var isStartPoint = (editor, point, at) => !!point && slate.Editor.isStart(editor, point, at);
+var normalizeEditor = (editor, options) => slate.Editor.normalize(editor, options);
+var removeEditorMark = (editor, key) => slate.Editor.removeMark(editor, key);
+
+// src/interfaces/node/getNode.ts
+var getNode = (root, path) => {
+  try {
+    for (let i = 0; i < path.length; i++) {
+      const p = path[i];
+      if (isText(root) || !root.children[p]) {
+        return null;
+      }
+      root = root.children[p];
+    }
+    return root;
+  } catch (error) {
+    return null;
+  }
+};
+var getNodeChildren = (root, path, options) => slate.Node.children(root, path, options);
+var getNodeLeaf = (root, path) => slate.Node.leaf(root, path);
+var getNodeProps = (node) => slate.Node.extractProps(node);
+var getNodeString = (node) => slate.Node.string(node);
+var isAncestor = (value) => slate.Element.isAncestor(value);
+var isCollapsed = (range) => !!range && slate.Range.isCollapsed(range);
+var isExpanded = (range) => !!range && slate.Range.isExpanded(range);
+var collapseSelection = (editor, options) => {
+  slate.Transforms.collapse(editor, options);
+};
+var deselect = (editor) => {
+  slate.Transforms.deselect(editor);
+};
+
+// src/utils/queryNode.ts
+function castArray2(value) {
+  return Array.isArray(value) ? value : [value];
+}
+var queryNode = (entry, { filter, allow, exclude, level, maxLevel } = {}) => {
+  if (!entry)
+    return false;
+  const [node, path] = entry;
+  if (level) {
+    const levels = castArray2(level);
+    if (!levels.includes(path.length)) {
+      return false;
+    }
+  }
+  if (maxLevel && path.length > maxLevel) {
+    return false;
+  }
+  if (filter && !filter(entry)) {
+    return false;
+  }
+  if (allow) {
+    const allows = castArray2(allow);
+    if (allows.length > 0 && !allows.includes(node.type)) {
+      return false;
+    }
+  }
+  if (exclude) {
+    const excludes = castArray2(exclude);
+    if (excludes.length > 0 && excludes.includes(node.type)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// src/interfaces/transforms/insertNodes.ts
+var insertNodes = (editor, nodes, _a = {}) => {
+  var _b = _a, { nextBlock, removeEmpty } = _b, options = __objRest(_b, ["nextBlock", "removeEmpty"]);
+  slate.withoutNormalizing(editor, () => {
+    if (removeEmpty) {
+      const blockEntry = getAboveNode(editor, { at: options.at });
+      if (blockEntry) {
+        const queryNodeOptions = removeEmpty === true ? {
+          allow: ["p"]
+        } : removeEmpty;
+        const { filter } = queryNodeOptions;
+        queryNodeOptions.filter = ([node, path]) => {
+          if (getNodeString(node))
+            return false;
+          const children = node.children;
+          if (children.some((n) => isInline(editor, n)))
+            return false;
+          return !filter || filter([node, path]);
+        };
+        if (queryNode(blockEntry, queryNodeOptions)) {
+          slate.removeNodes(editor, { at: blockEntry[1] });
+          nextBlock = false;
+        }
+      }
+    }
+    if (nextBlock) {
+      const { at = editor.selection } = options;
+      if (at) {
+        const endPoint = getEndPoint(editor, at);
+        const blockEntry = getAboveNode(editor, {
+          at: endPoint,
+          block: true
+        });
+        if (blockEntry) {
+          options.at = slate.Path.next(blockEntry[1]);
+        }
+      }
+    }
+    slate.Transforms.insertNodes(editor, nodes, options);
+  });
+};
+var setNodes = (editor, props, options) => slate.Transforms.setNodes(editor, props, options);
+var splitNodes = (editor, options) => slate.Transforms.splitNodes(editor, options);
+var unsetNodes = (editor, props, options) => {
+  return slate.Transforms.unsetNodes(editor, props, options);
+};
+var unwrapNodes = (editor, options) => {
+  slate.Transforms.unwrapNodes(editor, getQueryOptions(editor, options));
+};
+var wrapNodes = (editor, element, options) => {
+  unhangRange(editor, options == null ? void 0 : options.at, options);
+  slate.Transforms.wrapNodes(editor, element, options);
+};
+
+// src/queries/findNode.ts
+var findNode = (editor, options = {}) => {
+  try {
+    const nodeEntries = getNodeEntries(editor, __spreadValues({
+      at: editor.selection || []
+    }, getQueryOptions(editor, options)));
+    for (const [node, path] of nodeEntries) {
+      return [node, path];
+    }
+  } catch (error) {
+    return void 0;
+  }
+};
+
+// src/queries/someNode.ts
+var someNode = (editor, options) => {
+  return !!findNode(editor, options);
+};
+
+// src/transforms/setElements.ts
+var setElements = (editor, props, options) => setNodes(editor, props, options);
+
+exports.collapseSelection = collapseSelection;
+exports.createTEditor = createTEditor;
+exports.deselect = deselect;
+exports.findNode = findNode;
+exports.getAboveNode = getAboveNode;
+exports.getEdgePoints = getEdgePoints;
+exports.getEditorString = getEditorString;
+exports.getEndPoint = getEndPoint;
+exports.getMarks = getMarks;
+exports.getNextNode = getNextNode;
+exports.getNode = getNode;
+exports.getNodeChildren = getNodeChildren;
+exports.getNodeEntries = getNodeEntries;
+exports.getNodeEntry = getNodeEntry;
+exports.getNodeLeaf = getNodeLeaf;
+exports.getNodeProps = getNodeProps;
+exports.getNodeString = getNodeString;
+exports.getParentNode = getParentNode;
+exports.getPoint = getPoint;
+exports.getPointBefore = getPointBefore;
+exports.getPreviousNode = getPreviousNode;
+exports.getQueryOptions = getQueryOptions;
+exports.getStartPoint = getStartPoint;
+exports.insertNodes = insertNodes;
+exports.isAncestor = isAncestor;
+exports.isBlock = isBlock;
+exports.isCollapsed = isCollapsed;
+exports.isElement = isElement;
+exports.isElementEmpty = isElementEmpty;
+exports.isEndPoint = isEndPoint;
+exports.isExpanded = isExpanded;
+exports.isInline = isInline;
+exports.isStartPoint = isStartPoint;
+exports.isText = isText;
+exports.match = match;
+exports.normalizeEditor = normalizeEditor;
+exports.queryNode = queryNode;
+exports.removeEditorMark = removeEditorMark;
+exports.removeNodes = removeNodes;
+exports.select = select;
+exports.setElements = setElements;
+exports.setNodes = setNodes;
+exports.someNode = someNode;
+exports.splitNodes = splitNodes;
+exports.unhangRange = unhangRange;
+exports.unsetNodes = unsetNodes;
+exports.unwrapNodes = unwrapNodes;
+exports.withoutNormalizing = withoutNormalizing;
+exports.wrapNodes = wrapNodes;

package/dist/node_modules/@udecode/slate-react/dist/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var slateReact = require('slate-react');
+var index = require('../../slate/dist/index.js');
+
+// src/react-editor/blurEditor.ts
+var findNodePath = (editor, node) => {
+  try {
+    return slateReact.ReactEditor.findPath(editor, node);
+  } catch (error) {
+  }
+};
+var focusEditor = (editor, target) => {
+  if (target) {
+    index.withoutNormalizing(editor, () => {
+      index.deselect(editor);
+      index.select(editor, target);
+    });
+  }
+  slateReact.ReactEditor.focus(editor);
+};
+var isComposing = (editor) => slateReact.ReactEditor.isComposing(editor);
+var isEditorFocused = (editor) => slateReact.ReactEditor.isFocused(editor);
+var focusEditorEdge = (editor, {
+  edge = "start"
+} = {}) => {
+  const target = edge === "start" ? index.getStartPoint(editor, []) : index.getEndPoint(editor, []);
+  focusEditor(editor, target);
+};
+
+exports.findNodePath = findNodePath;
+exports.focusEditor = focusEditor;
+exports.focusEditorEdge = focusEditorEdge;
+exports.isComposing = isComposing;
+exports.isEditorFocused = isEditorFocused;

package/dist/node_modules/@udecode/slate-utils/dist/index.js

@@ -0,0 +1,230 @@
+'use strict';
+
+var index = require('../../slate/dist/index.js');
+var slate = require('slate');
+var castArray = require('../../../lodash/castArray.js');
+var map = require('../../../lodash/map.js');
+
+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;
+};
+var getBlockAbove = (editor, options = {}) => index.getAboveNode(editor, __spreadProps(__spreadValues({}, options), {
+  block: true
+}));
+var getEdgeBlocksAbove = (editor, _a = {}) => {
+  var _b = _a, { at: _at } = _b, options = __objRest(_b, ["at"]);
+  const at = _at != null ? _at : editor.selection;
+  if (!at)
+    return null;
+  const [start, end] = index.getEdgePoints(editor, at != null ? at : editor.selection);
+  const startBlock = getBlockAbove(editor, __spreadValues({
+    at: start
+  }, options));
+  if (!startBlock)
+    return null;
+  const endBlock = getBlockAbove(editor, __spreadValues({
+    at: end
+  }, options));
+  if (!endBlock)
+    return null;
+  return [startBlock, endBlock];
+};
+var getNextNodeStartPoint = (editor, at) => {
+  const nextEntry = index.getNextNode(editor, {
+    at
+  });
+  if (!nextEntry)
+    return;
+  return index.getStartPoint(editor, nextEntry[1]);
+};
+var isRangeAcrossBlocks = (editor, _a = {}) => {
+  var _b = _a, {
+    at
+  } = _b, options = __objRest(_b, [
+    "at"
+  ]);
+  if (!at)
+    at = editor.selection;
+  if (!at)
+    return;
+  const [start, end] = slate.Range.edges(at);
+  const startBlock = getBlockAbove(editor, __spreadValues({
+    at: start
+  }, options));
+  const endBlock = getBlockAbove(editor, __spreadValues({
+    at: end
+  }, options));
+  if (!startBlock && !endBlock)
+    return;
+  if (!startBlock || !endBlock)
+    return true;
+  return !slate.Path.equals(startBlock[1], endBlock[1]);
+};
+
+// src/queries/getPointBeforeLocation.ts
+var getPointBeforeLocation = (editor, at, options) => {
+  if (!options || !options.match && !options.matchString) {
+    return index.getPointBefore(editor, at, options);
+  }
+  const unitOffset = !options.unit || options.unit === "offset";
+  const matchStrings = options.matchString ? castArray.default(options.matchString) : [""];
+  let point;
+  matchStrings.some((matchString) => {
+    var _a, _b;
+    let beforeAt = at;
+    let previousBeforePoint = index.getPoint(editor, at, { edge: "end" });
+    const stackLength = matchString.length + 1;
+    const stack = Array.from({ length: stackLength });
+    let count = 0;
+    while (true) {
+      const beforePoint = index.getPointBefore(editor, beforeAt, options);
+      if (!beforePoint)
+        return;
+      if (isRangeAcrossBlocks(editor, {
+        at: {
+          anchor: beforePoint,
+          focus: previousBeforePoint
+        }
+      })) {
+        return;
+      }
+      const beforeString = index.getEditorString(editor, {
+        anchor: beforePoint,
+        focus: previousBeforePoint
+      });
+      let beforeStringToMatch = beforeString;
+      if (unitOffset && stackLength) {
+        stack.unshift({
+          point: beforePoint,
+          text: beforeString
+        });
+        stack.pop();
+        beforeStringToMatch = map.default(stack.slice(0, -1), "text").join("");
+      }
+      if (matchString === beforeStringToMatch || ((_a = options.match) == null ? void 0 : _a.call(options, { beforeString: beforeStringToMatch, beforePoint, at }))) {
+        if (options.afterMatch) {
+          if (stackLength && unitOffset) {
+            point = (_b = stack.at(-1)) == null ? void 0 : _b.point;
+            return !!point;
+          }
+          point = previousBeforePoint;
+          return true;
+        }
+        point = beforePoint;
+        return true;
+      }
+      previousBeforePoint = beforePoint;
+      beforeAt = beforePoint;
+      count += 1;
+      if (!options.skipInvalid && (!matchString || count >= matchString.length))
+        return;
+    }
+  });
+  return point;
+};
+var getPointFromLocation = (editor, {
+  at = editor.selection,
+  focus
+} = {}) => {
+  let point;
+  if (slate.Range.isRange(at))
+    point = focus ? at.focus : at.anchor;
+  if (slate.Point.isPoint(at))
+    point = at;
+  if (slate.Path.isPath(at))
+    point = { path: at, offset: 0 };
+  return point;
+};
+var getPreviousNodeEndPoint = (editor, at) => {
+  const prevEntry = index.getPreviousNode(editor, {
+    at
+  });
+  if (!prevEntry)
+    return;
+  return index.getEndPoint(editor, prevEntry[1]);
+};
+var getRangeBefore = (editor, at, options) => {
+  const anchor = getPointBeforeLocation(editor, at, options);
+  if (!anchor)
+    return;
+  const focus = index.getPoint(editor, at, { edge: "end" });
+  return {
+    anchor,
+    focus
+  };
+};
+var getRangeFromBlockStart = (editor, options = {}) => {
+  var _a;
+  const path = (_a = getBlockAbove(editor, options)) == null ? void 0 : _a[1];
+  if (!path)
+    return;
+  const start = index.getStartPoint(editor, path);
+  const focus = getPointFromLocation(editor, options);
+  if (!focus)
+    return;
+  return { anchor: start, focus };
+};
+var isSelectionExpanded = (editor) => index.isExpanded(editor.selection);
+var insertElements = (editor, nodes, options) => {
+  index.insertNodes(editor, nodes, options);
+};
+var removeNodeChildren = (editor, path, options) => {
+  index.withoutNormalizing(editor, () => {
+    for (const [, childPath] of index.getNodeChildren(editor, path, {
+      reverse: true
+    })) {
+      index.removeNodes(editor, __spreadProps(__spreadValues({}, options), { at: childPath }));
+    }
+  });
+};
+
+// src/transforms/replaceNodeChildren.ts
+var replaceNodeChildren = (editor, { at, nodes, insertOptions, removeOptions }) => {
+  index.withoutNormalizing(editor, () => {
+    removeNodeChildren(editor, at, removeOptions);
+    index.insertNodes(editor, nodes, __spreadProps(__spreadValues({}, insertOptions), {
+      at: at.concat([0])
+    }));
+  });
+};
+
+exports.getBlockAbove = getBlockAbove;
+exports.getEdgeBlocksAbove = getEdgeBlocksAbove;
+exports.getNextNodeStartPoint = getNextNodeStartPoint;
+exports.getPointBeforeLocation = getPointBeforeLocation;
+exports.getPointFromLocation = getPointFromLocation;
+exports.getPreviousNodeEndPoint = getPreviousNodeEndPoint;
+exports.getRangeBefore = getRangeBefore;
+exports.getRangeFromBlockStart = getRangeFromBlockStart;
+exports.insertElements = insertElements;
+exports.isRangeAcrossBlocks = isRangeAcrossBlocks;
+exports.isSelectionExpanded = isSelectionExpanded;
+exports.replaceNodeChildren = replaceNodeChildren;