onchain-lexical-instance 0.0.12 → 0.0.13

package/dist/OnchainLexicalInstance.js

@@ -15,10 +15,11 @@ var LexicalHorizontalRuleNode = require('@lexical/react/LexicalHorizontalRuleNod
 var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
 var React = require('react');
 var jsxRuntime = require('react/jsx-runtime');
-var onchainLexicalMarkdown = require('onchain-lexical-markdown');
 var list = require('@lexical/list');
-var selection = require('@lexical/selection');
 var table = require('@lexical/table');
+var onchainLexicalMarkdown = require('onchain-lexical-markdown');
+var traversal = require('onchain-utility/traversal');
+var selection = require('@lexical/selection');
 var useLexicalNodeSelection = require('@lexical/react/useLexicalNodeSelection');
 var hooks = require('onchain-utility/hooks');
 var richText = require('@lexical/rich-text');
@@ -40,7 +41,6 @@ var sharedHistory = require('onchain-lexical-context/sharedHistory');
 var ContentEditable = require('onchain-lexical-ui/ContentEditable');
 var ImageResizer = require('onchain-lexical-ui/ImageResizer');
 var onchainUtility = require('onchain-utility');
-var traversal = require('onchain-utility/traversal');
 var Skeleton = require('onchain-lexical-ui/Skeleton');
 var settings = require('onchain-lexical-context/settings');
 var DropDown = require('onchain-lexical-ui/DropDown');
@@ -143,6 +143,9 @@ const OPEN_CREATE_WINDOW = lexical.createCommand('OPEN_CREATE_WINDOW');
 /** 添加新的实例节点 */
 const ADD_NEW_INSTANCE_NODE = lexical.createCommand('ADD_NEW_INSTANCE_NODE');
 
+/** 拆分的实例节点 */
+const SPLIT_INSTANCE_NODE = lexical.createCommand('ADD_NEW_INSTANCE_NODE');
+
 /** 删除实例节点 */
 const DELETE_INSTANCE_NODE = 'DELETE_INSTANCE_NODE';
 
@@ -1088,6 +1091,59 @@ function correctedInstanceParagraph(nodes, createParagraph) {
   return nodes;
 }
 
+/** 添加新实例节点 */
+function $addInstancesNode({
+  isAddChildLevel,
+  instances,
+  insNodeKey
+}) {
+  if (insNodeKey) {
+    const insNode = lexical.$getNodeByKey(insNodeKey);
+    if ($isInstanceNode(insNode)) {
+      const newInsNodes = instances.map(instance => {
+        const contentText = getTemporaryContentText(instance);
+        if (contentText) {
+          const node = $createTitleOnlyInstanceNode(instance);
+          const fragment = $createFragmentNode();
+          onchainLexicalMarkdown.$textToRichNodes(fragment, contentText);
+          const nodes = correctedInstanceParagraph(fragment.getChildren(), () => $createInstanceParagraphNode());
+          node.append(...nodes);
+          return node;
+        } else {
+          return $createInstanceNode(instance);
+        }
+      });
+      if (isAddChildLevel) {
+        const [insChildNode] = insNode.getSelfInstanceChildren();
+        if (insChildNode) {
+          for (let index = newInsNodes.length - 1; index > -1; index--) {
+            const current = newInsNodes[index];
+            const pre = newInsNodes[index + 1];
+            if (pre) {
+              pre.insertBefore(current);
+            } else {
+              insChildNode.insertBefore(current);
+            }
+          }
+        } else {
+          insNode.append(...newInsNodes);
+        }
+      } else {
+        for (let index = 0; index < newInsNodes.length; index++) {
+          const current = newInsNodes[index];
+          const pre = newInsNodes[index - 1];
+          if (pre) {
+            pre.insertAfter(current);
+          } else {
+            insNode.insertAfter(current);
+          }
+        }
+      }
+      newInsNodes[0].selectStart();
+    }
+  }
+}
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -23228,165 +23284,6 @@ function $handleListInsertParagraph() {
   return true;
 }
 
-/** @noInheritDoc */
-class InstanceListNode extends list.ListNode {
-  static getType() {
-    return 'List';
-  }
-  static clone(node) {
-    const listType = node.__listType || TAG_TO_LIST_TYPE[node.__tag];
-    return new InstanceListNode(listType, node.__start, node.__key);
-  }
-  static transform() {
-    return node => {
-      if (!$isInstanceListNode(node)) {
-        formatDevErrorMessage(`node is not a InstanceListNode`);
-      }
-      mergeNextSiblingListIfSameType(node);
-      updateChildrenListItemValue(node);
-    };
-  }
-  static importDOM() {
-    return {
-      ol: () => ({
-        conversion: $convertInstanceListNode,
-        priority: 0
-      }),
-      ul: () => ({
-        conversion: $convertInstanceListNode,
-        priority: 0
-      })
-    };
-  }
-  static importJSON(serializedNode) {
-    return $createInstanceListNode().updateFromJSON(serializedNode);
-  }
-  createDOM(config) {
-    const element = super.createDOM(config);
-    setDisable(this, element);
-    return element;
-  }
-  updateFromJSON(serializedNode) {
-    return super.updateFromJSON(serializedNode).setListType(serializedNode.listType).setStart(serializedNode.start);
-  }
-  exportJSON() {
-    return {
-      ...super.exportJSON(),
-      listType: this.getListType(),
-      start: this.getStart(),
-      tag: this.getTag()
-    };
-  }
-  splice(start, deleteCount, nodesToInsert) {
-    let listItemNodesToInsert = nodesToInsert;
-    for (let i = 0; i < nodesToInsert.length; i++) {
-      const node = nodesToInsert[i];
-      if (!$isInstanceListItemNode(node)) {
-        if (listItemNodesToInsert === nodesToInsert) {
-          listItemNodesToInsert = [...nodesToInsert];
-        }
-        listItemNodesToInsert[i] = $createInstanceListItemNode().append(lexical.$isElementNode(node) && !($isInstanceListNode(node) || node.isInline()) ? lexical.$createTextNode(node.getTextContent()) : node);
-      }
-    }
-    return super.splice(start, deleteCount, listItemNodesToInsert);
-  }
-  extractWithChild(child) {
-    return $isInstanceListItemNode(child);
-  }
-}
-
-/*
- * This function normalizes the children of a InstanceListNode after the conversion from HTML,
- * ensuring that they are all ListItemNodes and contain either a single nested InstanceListNode
- * or some other inline content.
- */
-function $normalizeChildren(nodes) {
-  const normalizedListItems = [];
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    if ($isInstanceListItemNode(node)) {
-      normalizedListItems.push(node);
-      const children = node.getChildren();
-      if (children.length > 1) {
-        children.forEach(child => {
-          if ($isInstanceListNode(child)) {
-            normalizedListItems.push($wrapInInstanceListItem(child));
-          }
-        });
-      }
-    } else {
-      normalizedListItems.push($wrapInInstanceListItem(node));
-    }
-  }
-  return normalizedListItems;
-}
-function isDomChecklist(domNode) {
-  if (domNode.getAttribute('__lexicallisttype') === 'check' ||
-  // is github checklist
-  domNode.classList.contains('contains-task-list')) {
-    return true;
-  }
-  // if children are checklist items, the node is a checklist ul. Applicable for googledoc checklist pasting.
-  for (const child of domNode.childNodes) {
-    if (lexical.isHTMLElement(child) && child.hasAttribute('aria-checked')) {
-      return true;
-    }
-  }
-  return false;
-}
-function $convertInstanceListNode(domNode) {
-  const nodeName = domNode.nodeName.toLowerCase();
-  let node = null;
-  if (nodeName === 'ol') {
-    // @ts-ignore
-    const start = domNode.start;
-    node = $createInstanceListNode('number', start);
-  } else if (nodeName === 'ul') {
-    if (isDomChecklist(domNode)) {
-      node = $createInstanceListNode('check');
-    } else {
-      node = $createInstanceListNode('bullet');
-    }
-  }
-  return {
-    after: $normalizeChildren,
-    node
-  };
-}
-const TAG_TO_LIST_TYPE = {
-  ol: 'number',
-  ul: 'bullet'
-};
-
-/**
- * Wraps a node into a ListItemNode.
- * @param node - The node to be wrapped into a ListItemNode
- * @returns The ListItemNode which the passed node is wrapped in.
- */
-function $wrapInInstanceListItem(node) {
-  const listItemWrapper = $createInstanceListItemNode();
-  return listItemWrapper.append(node);
-}
-
-/**
- * Creates a InstanceListNode of listType.
- * @param listType - The type of list to be created. Can be 'number', 'bullet', or 'check'.
- * @param start - Where an ordered list starts its count, start = 1 if left undefined.
- * @returns The new InstanceListNode
- */
-function $createInstanceListNode(listType = 'number', start = 1) {
-  return lexical.$applyNodeReplacement(new InstanceListNode(listType, start));
-}
-
-/**
- * Checks to see if the node is a InstanceListNode.
- * @param node - The node to be checked.
- * @returns true if the node is a InstanceListNode, false otherwise.
- */
-function $isInstanceListNode(node) {
-  return node instanceof InstanceListNode;
-}
-
 /** @noInheritDoc */
 class InstanceListItemNode extends list.ListItemNode {
   static getType() {
@@ -23514,6 +23411,9 @@ class InstanceListItemNode extends list.ListItemNode {
       super.remove(preserveEmptyParent);
     }
   }
+  defaultRemove(preserveEmptyParent) {
+    super.remove(preserveEmptyParent);
+  }
   insertNewAfter(selection$1, restoreSelection = true) {
     const [node] = selection$1.getNodes();
     if ($isInstanceListItemNode(node) && node.getChildren().length === 0) {
@@ -23614,6 +23514,165 @@ function $registerInstanceListItemInsertParagraph(editor) {
   }, lexical.COMMAND_PRIORITY_NORMAL);
 }
 
+/** @noInheritDoc */
+class InstanceListNode extends list.ListNode {
+  static getType() {
+    return 'List';
+  }
+  static clone(node) {
+    const listType = node.__listType || TAG_TO_LIST_TYPE[node.__tag];
+    return new InstanceListNode(listType, node.__start, node.__key);
+  }
+  static transform() {
+    return node => {
+      if (!$isInstanceListNode(node)) {
+        formatDevErrorMessage(`node is not a InstanceListNode`);
+      }
+      mergeNextSiblingListIfSameType(node);
+      updateChildrenListItemValue(node);
+    };
+  }
+  static importDOM() {
+    return {
+      ol: () => ({
+        conversion: $convertInstanceListNode,
+        priority: 0
+      }),
+      ul: () => ({
+        conversion: $convertInstanceListNode,
+        priority: 0
+      })
+    };
+  }
+  static importJSON(serializedNode) {
+    return $createInstanceListNode().updateFromJSON(serializedNode);
+  }
+  createDOM(config) {
+    const element = super.createDOM(config);
+    setDisable(this, element);
+    return element;
+  }
+  updateFromJSON(serializedNode) {
+    return super.updateFromJSON(serializedNode).setListType(serializedNode.listType).setStart(serializedNode.start);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      listType: this.getListType(),
+      start: this.getStart(),
+      tag: this.getTag()
+    };
+  }
+  splice(start, deleteCount, nodesToInsert) {
+    let listItemNodesToInsert = nodesToInsert;
+    for (let i = 0; i < nodesToInsert.length; i++) {
+      const node = nodesToInsert[i];
+      if (!$isInstanceListItemNode(node)) {
+        if (listItemNodesToInsert === nodesToInsert) {
+          listItemNodesToInsert = [...nodesToInsert];
+        }
+        listItemNodesToInsert[i] = $createInstanceListItemNode().append(lexical.$isElementNode(node) && !($isInstanceListNode(node) || node.isInline()) ? lexical.$createTextNode(node.getTextContent()) : node);
+      }
+    }
+    return super.splice(start, deleteCount, listItemNodesToInsert);
+  }
+  extractWithChild(child) {
+    return $isInstanceListItemNode(child);
+  }
+}
+
+/*
+ * This function normalizes the children of a InstanceListNode after the conversion from HTML,
+ * ensuring that they are all ListItemNodes and contain either a single nested InstanceListNode
+ * or some other inline content.
+ */
+function $normalizeChildren(nodes) {
+  const normalizedListItems = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if ($isInstanceListItemNode(node)) {
+      normalizedListItems.push(node);
+      const children = node.getChildren();
+      if (children.length > 1) {
+        children.forEach(child => {
+          if ($isInstanceListNode(child)) {
+            normalizedListItems.push($wrapInInstanceListItem(child));
+          }
+        });
+      }
+    } else {
+      normalizedListItems.push($wrapInInstanceListItem(node));
+    }
+  }
+  return normalizedListItems;
+}
+function isDomChecklist(domNode) {
+  if (domNode.getAttribute('__lexicallisttype') === 'check' ||
+  // is github checklist
+  domNode.classList.contains('contains-task-list')) {
+    return true;
+  }
+  // if children are checklist items, the node is a checklist ul. Applicable for googledoc checklist pasting.
+  for (const child of domNode.childNodes) {
+    if (lexical.isHTMLElement(child) && child.hasAttribute('aria-checked')) {
+      return true;
+    }
+  }
+  return false;
+}
+function $convertInstanceListNode(domNode) {
+  const nodeName = domNode.nodeName.toLowerCase();
+  let node = null;
+  if (nodeName === 'ol') {
+    // @ts-ignore
+    const start = domNode.start;
+    node = $createInstanceListNode('number', start);
+  } else if (nodeName === 'ul') {
+    if (isDomChecklist(domNode)) {
+      node = $createInstanceListNode('check');
+    } else {
+      node = $createInstanceListNode('bullet');
+    }
+  }
+  return {
+    after: $normalizeChildren,
+    node
+  };
+}
+const TAG_TO_LIST_TYPE = {
+  ol: 'number',
+  ul: 'bullet'
+};
+
+/**
+ * Wraps a node into a ListItemNode.
+ * @param node - The node to be wrapped into a ListItemNode
+ * @returns The ListItemNode which the passed node is wrapped in.
+ */
+function $wrapInInstanceListItem(node) {
+  const listItemWrapper = $createInstanceListItemNode();
+  return listItemWrapper.append(node);
+}
+
+/**
+ * Creates a InstanceListNode of listType.
+ * @param listType - The type of list to be created. Can be 'number', 'bullet', or 'check'.
+ * @param start - Where an ordered list starts its count, start = 1 if left undefined.
+ * @returns The new InstanceListNode
+ */
+function $createInstanceListNode(listType = 'number', start = 1) {
+  return lexical.$applyNodeReplacement(new InstanceListNode(listType, start));
+}
+
+/**
+ * Checks to see if the node is a InstanceListNode.
+ * @param node - The node to be checked.
+ * @returns true if the node is a InstanceListNode, false otherwise.
+ */
+function $isInstanceListNode(node) {
+  return node instanceof InstanceListNode;
+}
+
 /** @noInheritDoc */
 class InstanceTableNode extends table.TableNode {
   static getType() {
@@ -23778,49 +23837,131 @@ const InstancePlugin = props => {
       instances,
       isAddChildLevel
     }) => {
-      if (insNodeKey) {
-        const insNode = lexical.$getNodeByKey(insNodeKey);
-        if ($isInstanceNode(insNode)) {
-          const newInsNodes = instances.map(instance => {
-            const contentText = getTemporaryContentText(instance);
-            if (contentText) {
-              const node = $createTitleOnlyInstanceNode(instance);
-              const fragment = $createFragmentNode();
-              onchainLexicalMarkdown.$textToRichNodes(fragment, contentText);
-              const nodes = correctedInstanceParagraph(fragment.getChildren(), () => $createInstanceParagraphNode());
-              node.append(...nodes);
-              return node;
-            } else {
-              return $createInstanceNode(instance);
-            }
-          });
-          if (isAddChildLevel) {
-            const [insChildNode] = insNode.getSelfInstanceChildren();
-            if (insChildNode) {
-              for (let index = newInsNodes.length - 1; index > -1; index--) {
-                const current = newInsNodes[index];
-                const pre = newInsNodes[index + 1];
-                if (pre) {
-                  pre.insertBefore(current);
-                } else {
-                  insChildNode.insertBefore(current);
-                }
+      $addInstancesNode({
+        insNodeKey,
+        instances,
+        isAddChildLevel
+      });
+      return true;
+    }, lexical.COMMAND_PRIORITY_LOW), /** 需求拆分 */
+    editor.registerCommand(SPLIT_INSTANCE_NODE, ({
+      selection,
+      insNodeKey,
+      instance,
+      isAddChildLevel
+    }) => {
+      lexical.$setSelection(null);
+      if (lexical.$isRangeSelection(selection) || table.$isTableSelection(selection)) {
+        const forwardSelection = lexical.$createRangeSelection();
+        const [startPoint, endPoint] = selection.isBackward() ? [selection.focus, selection.anchor] : [selection.anchor, selection.focus];
+        forwardSelection.anchor.set(startPoint.key, startPoint.offset, startPoint.type);
+        forwardSelection.focus.set(endPoint.key, endPoint.offset, endPoint.type);
+        const nodes = forwardSelection.extract();
+        const hasElementNode = nodes.some(node => lexical.$isElementNode(node));
+        const elementNodes = [];
+        if (!hasElementNode) {
+          const paragraph = $createInstanceParagraphNode();
+          nodes.forEach(node => node.remove());
+          paragraph.append(...nodes);
+          elementNodes.push(paragraph);
+        } else {
+          if (table.$isTableSelection(selection)) {
+            const size = {
+              cell: 0,
+              row: 0,
+              rowIndex: Infinity
+            };
+            const newRowMap = new Map();
+            const configs = selection.getNodes().filter(node => table.$isTableCellNode(node)).map(node => {
+              const row = node.getParent();
+              const rowIndex = row.getIndexWithinParent();
+              if (size.rowIndex !== rowIndex) {
+                size.rowIndex = rowIndex;
+                size.cell = 1;
+                size.row++;
+              } else {
+                size.cell++;
               }
+              if (!newRowMap.has(rowIndex)) {
+                newRowMap.set(rowIndex, table.$createTableRowNode());
+              }
+              return {
+                col: node.getIndexWithinParent(),
+                node,
+                rowIndex: rowIndex,
+                rowNode: row
+              };
+            });
+            const tableNode = $createInstanceTableNode();
+            const maxCellSize = configs[0].rowNode.getChildrenSize();
+            const maxRowSize = configs[0].rowNode.getParent()?.getChildrenSize();
+            if (size.cell === maxCellSize) {
+              tableNode.append(...configs.map(config => config.rowNode));
             } else {
-              insNode.append(...newInsNodes);
+              configs.forEach(config => {
+                const rowNode = newRowMap.get(config.rowIndex) || newRowMap.set(config.rowIndex, table.$createTableRowNode()).get(config.rowIndex);
+                if (size.row !== maxRowSize) {
+                  config.node.replace(table.$createTableCellNode());
+                }
+                rowNode.append(config.node);
+              });
+              newRowMap.values().forEach(row => {
+                tableNode.append(row);
+              });
             }
+            elementNodes.push(tableNode);
           } else {
-            for (let index = 0; index < newInsNodes.length; index++) {
-              const current = newInsNodes[index];
-              const pre = newInsNodes[index - 1];
-              if (pre) {
-                pre.insertAfter(current);
-              } else {
-                insNode.insertAfter(current);
+            const [startNode, endNode] = [startPoint.getNode(), endPoint.getNode()];
+            const startAncestors = getAncestors(startNode);
+            const endAncestors = getAncestors(endNode);
+            const sameLevel = new Map();
+            startAncestors.some((sa, idx) => {
+              const eaIdx = endAncestors.findIndex((ea, idx) => ea.getKey() === sa.getKey());
+              const isSame = eaIdx > -1;
+              if (isSame) {
+                sameLevel.set('start', startAncestors[idx - 1]);
+                sameLevel.set('end', endAncestors[eaIdx - 1]);
+              }
+              return isSame;
+            });
+            const next = $getFollowUpNode({
+              node: startNode,
+              terminate: sameLevel.get('start'),
+              type: 'getNextSiblings'
+            });
+            const previous = $getFollowUpNode({
+              node: endNode.getNextSibling() || endNode,
+              terminate: sameLevel.get('end'),
+              type: 'getPreviousSiblings'
+            });
+            let node = next.original.getNextSibling();
+            while (node && node.getKey() !== previous.original.getKey()) {
+              elementNodes.push(node);
+              node = node.getNextSibling();
+            }
+            elementNodes.unshift(...next.nodes);
+            elementNodes.push(...previous.nodes);
+            // 添加嵌套Item父List
+            if (elementNodes.every(node => list.$isListItemNode(node))) {
+              const originalListNode = utils$1.$findMatchingParent(next.original, node => $isInstanceListNode(node));
+              if (originalListNode) {
+                const listNode = $createInstanceListNode(originalListNode.getListType());
+                listNode.append(...elementNodes);
+                elementNodes.length = 0;
+                elementNodes.push(listNode);
               }
             }
           }
         }
+        const paragraph = $createInstanceParagraphNode();
+        paragraph.append(...elementNodes);
+        const json = lexical.exportNodeToJSON(paragraph);
+        setTemporaryContentText(instance, onchainLexicalMarkdown.getStorageSerializedString(json.children));
+        $addInstancesNode({
+          insNodeKey,
+          instances: [instance],
+          isAddChildLevel
+        });
       }
       return true;
     }, lexical.COMMAND_PRIORITY_LOW));
@@ -23832,6 +23973,119 @@ const InstancePlugin = props => {
   }, []);
   return /*#__PURE__*/React.createElement(React.Fragment, {}, /*#__PURE__*/React.createElement(HorizontalRulePlugin));
 };
+function getDescendants(node) {
+  if (lexical.$isElementNode(node)) {
+    return traversal.dfs(node.getChildren(), node => {
+      if (lexical.$isElementNode(node)) {
+        return node.getChildren();
+      } else {
+        return [];
+      }
+    });
+  } else {
+    return [];
+  }
+}
+function getAncestors(node) {
+  const parent = node.getParent();
+  if (parent) {
+    return traversal.dfs([parent], node => {
+      const parent = node.getParent();
+      if (parent) {
+        return [parent];
+      } else {
+        return [];
+      }
+    });
+  } else {
+    return [];
+  }
+}
+function $getFollowUpNode({
+  node,
+  terminate,
+  type
+}) {
+  const isTableCellNode = table.$isTableCellNode(node);
+  if (isTableCellNode) {
+    const descendants = getDescendants(node);
+    const text = lexical.$createTextNode('');
+    node = text;
+    if (type === 'getNextSiblings') {
+      descendants[0].insertBefore(text);
+    } else {
+      descendants[descendants.length - 1].insertAfter(text);
+    }
+  }
+  const ancestors = terminate ? [terminate] : getAncestors(node);
+  const index = ancestors.findIndex(node => $isInstanceNode(node));
+  const term = ancestors[index - 1] || ancestors[ancestors.length - 1];
+  const original = term;
+
+  // console.log(
+  //   {
+  //     node,
+  //     original,
+  //     terminate,
+  //     type,
+  //   },
+  //   'getFollowUpNode',
+  // );
+
+  const set = new Set();
+  const termKey = term.getKey();
+  traversal.dfs([node], node => {
+    const parent = node.getParent();
+    const parentKey = parent?.getKey();
+    const isStop = parentKey === termKey;
+    const siblings = node[type]();
+    siblings.forEach(sibling => {
+      if ($isInstanceListItemNode(sibling)) {
+        sibling.defaultRemove();
+        return;
+      }
+      sibling.remove();
+    });
+    if (parent) {
+      const constructor = parent.constructor;
+      const newParent = constructor.importJSON(parent.exportJSON());
+      newParent.append(...siblings);
+      if (set.size) {
+        const children = Array.from(set)[0];
+        if (type === 'getNextSiblings') {
+          if (siblings.length) {
+            siblings[0].insertBefore(children);
+          } else {
+            newParent.append(children);
+          }
+        } else {
+          if (siblings.length) {
+            siblings[siblings.length - 1].insertAfter(children);
+          } else {
+            newParent.append(children);
+          }
+        }
+        set.clear();
+      }
+      set.add(newParent);
+    }
+    if (isStop || !parent) {
+      return [];
+    } else {
+      return [parent].filter(Boolean);
+    }
+  });
+  if (isTableCellNode) {
+    const tableNode = utils$1.$findMatchingParent(node, node => $isInstanceTableNode(node));
+    if (tableNode) {
+      tableNode.remove();
+    }
+  }
+  return {
+    nodes: Array.from(set.values()),
+    original
+  };
+}
 
 var css_248z$3 = ".styles-module_internalLink__3B9ii{color:#0563b0;cursor:pointer}.styles-module_internalLink__3B9ii>span:first-of-type:not(:empty){padding-right:4px}.styles-module_internalLink__3B9ii:hover{color:#0563b0}.styles-module_internalLink__3B9ii:hover>span:nth-of-type(2){text-decoration:underline}";
 var Styles$3 = {"internalLink":"styles-module_internalLink__3B9ii"};
@@ -25194,6 +25448,7 @@ var InlineImageComponent$1 = {
   default: InlineImageComponent
 };
 
+exports.$addInstancesNode = $addInstancesNode;
 exports.$createBarDecoratorNode = $createBarDecoratorNode;
 exports.$createCollapsibleContainerNode = $createCollapsibleContainerNode;
 exports.$createCollapsibleContentNode = $createCollapsibleContentNode;
@@ -25312,6 +25567,7 @@ exports.PARAMETERS_UPDATE = PARAMETERS_UPDATE;
 exports.PageBreakNode = PageBreakNode;
 exports.ParametersNode = ParametersNode;
 exports.PlaceholderDecoratorNode = PlaceholderDecoratorNode;
+exports.SPLIT_INSTANCE_NODE = SPLIT_INSTANCE_NODE;
 exports.clearCache = clearCache;
 exports.correctedInstanceParagraph = correctedInstanceParagraph;
 exports.fixedAddress = fixedAddress;