npm - @atlaskit/editor-core - Versions diffs - 178.1.0 → 178.1.2 - Mend

@atlaskit/editor-core 178.1.0 → 178.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2514) hide show

package/dist/es2019/editor.js CHANGED Viewed

@@ -1,5 +1,4 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /** @jsx jsx */
 import React, { Fragment } from 'react';
 import { css, jsx } from '@emotion/react';
@@ -33,37 +32,28 @@ const fullHeight = css`
 export default class Editor extends React.Component {
   constructor(props, context) {
     var _props$performanceTra, _props$performanceTra2, _props$featureFlags;
     super(props);
     _defineProperty(this, "prepareExtensionProvider", memoizeOne(extensionProviders => {
       if (!extensionProviders) {
         return;
       }
       if (typeof extensionProviders === 'function') {
         return combineExtensionProviders(extensionProviders(this.editorActions));
       }
       return combineExtensionProviders(extensionProviders);
     }));
     _defineProperty(this, "prepareQuickInsertProvider", (extensionProvider, quickInsert) => {
       const quickInsertProvider = quickInsert && typeof quickInsert !== 'boolean' && quickInsert.provider;
       const extensionQuickInsertProvider = extensionProvider && extensionProviderToQuickInsertProvider(extensionProvider, this.editorActions, this.createAnalyticsEvent);
       return quickInsertProvider && extensionQuickInsertProvider ? combineQuickInsertProviders([quickInsertProvider, extensionQuickInsertProvider]) : quickInsertProvider || extensionQuickInsertProvider;
     });
     _defineProperty(this, "handleSave", view => {
       if (!this.props.onSave) {
         return;
       }
       return this.props.onSave(view);
     });
     _defineProperty(this, "handleAnalyticsEvent", data => fireAnalyticsEvent(this.createAnalyticsEvent)(data));
     this.providerFactory = new ProviderFactory();
     this.deprecationWarnings(props);
     this.onEditorCreated = this.onEditorCreated.bind(this);
@@ -73,16 +63,12 @@ export default class Editor extends React.Component {
     this.editorSessionId = uuid();
     this.startTime = performance.now();
     startMeasure(measurements.EDITOR_MOUNTED);
     if ((_props$performanceTra = props.performanceTracking) !== null && _props$performanceTra !== void 0 && (_props$performanceTra2 = _props$performanceTra.ttiTracking) !== null && _props$performanceTra2 !== void 0 && _props$performanceTra2.enabled || (_props$featureFlags = props.featureFlags) !== null && _props$featureFlags !== void 0 && _props$featureFlags.ufo) {
       var _props$performanceTra5, _props$performanceTra6, _props$performanceTra7, _props$performanceTra8;
       measureTTI((tti, ttiFromInvocation, canceled) => {
         var _props$performanceTra3, _props$performanceTra4, _props$featureFlags2;
         if ((_props$performanceTra3 = props.performanceTracking) !== null && _props$performanceTra3 !== void 0 && (_props$performanceTra4 = _props$performanceTra3.ttiTracking) !== null && _props$performanceTra4 !== void 0 && _props$performanceTra4.enabled && this.createAnalyticsEvent) {
           var _ttiTracking;
           const ttiEvent = {
             payload: {
               action: ACTION.EDITOR_TTI,
@@ -95,7 +81,6 @@ export default class Editor extends React.Component {
               eventType: EVENT_TYPE.OPERATIONAL
             }
           };
           if ((_ttiTracking = props.performanceTracking.ttiTracking) !== null && _ttiTracking !== void 0 && _ttiTracking.trackSeverity) {
             const {
               ttiSeverityNormalThreshold,
@@ -110,41 +95,33 @@ export default class Editor extends React.Component {
             ttiEvent.payload.attributes.ttiSeverity = ttiSeverity;
             ttiEvent.payload.attributes.ttiFromInvocationSeverity = ttiFromInvocationSeverity;
           }
           fireAnalyticsEvent(this.createAnalyticsEvent)(ttiEvent);
         }
         if ((_props$featureFlags2 = props.featureFlags) !== null && _props$featureFlags2 !== void 0 && _props$featureFlags2.ufo) {
           var _this$experienceStore, _this$experienceStore2;
           (_this$experienceStore = this.experienceStore) === null || _this$experienceStore === void 0 ? void 0 : _this$experienceStore.mark(EditorExperience.loadEditor, ACTION.EDITOR_TTI, tti);
           (_this$experienceStore2 = this.experienceStore) === null || _this$experienceStore2 === void 0 ? void 0 : _this$experienceStore2.success(EditorExperience.loadEditor);
         }
       }, (_props$performanceTra5 = props.performanceTracking) === null || _props$performanceTra5 === void 0 ? void 0 : (_props$performanceTra6 = _props$performanceTra5.ttiTracking) === null || _props$performanceTra6 === void 0 ? void 0 : _props$performanceTra6.ttiIdleThreshold, (_props$performanceTra7 = props.performanceTracking) === null || _props$performanceTra7 === void 0 ? void 0 : (_props$performanceTra8 = _props$performanceTra7.ttiTracking) === null || _props$performanceTra8 === void 0 ? void 0 : _props$performanceTra8.ttiCancelTimeout);
     }
     const _extensionProvider = this.prepareExtensionProvider(props.extensionProviders);
     const _quickInsertProvider = this.prepareQuickInsertProvider(_extensionProvider, props.quickInsert);
     this.state = {
       extensionProvider: _extensionProvider,
       quickInsertProvider: _quickInsertProvider
     };
   }
   componentDidMount() {
     stopMeasure(measurements.EDITOR_MOUNTED, this.sendDurationAnalytics(ACTION.EDITOR_MOUNTED));
     this.handleProviders(this.props);
   }
   componentDidUpdate(prevProps) {
     const {
       extensionProviders,
       quickInsert
     } = this.props;
-    if (extensionProviders && extensionProviders !== prevProps.extensionProviders || // Though this will introduce some performance regression related to quick insert
+    if (extensionProviders && extensionProviders !== prevProps.extensionProviders ||
+    // Though this will introduce some performance regression related to quick insert
     // loading but we can remove it soon when Forge will move to new API.
     // quickInsert={Promise.resolve(consumerQuickInsert)} is one of the main reason behind this performance issue.
     quickInsert && quickInsert !== prevProps.quickInsert) {
@@ -156,34 +133,26 @@ export default class Editor extends React.Component {
       }, () => this.handleProviders(this.props));
       return;
     }
     this.handleProviders(this.props);
   }
   componentWillUnmount() {
     var _this$props, _this$props$performan, _this$props$performan2, _this$props$featureFl;
     this.unregisterEditorFromActions();
     this.providerFactory.destroy();
     clearMeasure(measurements.EDITOR_MOUNTED);
     ((_this$props = this.props) === null || _this$props === void 0 ? void 0 : (_this$props$performan = _this$props.performanceTracking) === null || _this$props$performan === void 0 ? void 0 : (_this$props$performan2 = _this$props$performan.onEditorReadyCallbackTracking) === null || _this$props$performan2 === void 0 ? void 0 : _this$props$performan2.enabled) && clearMeasure(measurements.ON_EDITOR_READY_CALLBACK);
     if ((_this$props$featureFl = this.props.featureFlags) !== null && _this$props$featureFl !== void 0 && _this$props$featureFl.ufo) {
       var _this$experienceStore3;
       (_this$experienceStore3 = this.experienceStore) === null || _this$experienceStore3 === void 0 ? void 0 : _this$experienceStore3.abortAll({
         reason: 'editor component unmounted'
       });
     }
   }
   trackEditorActions(editorActions, props) {
     var _props$performanceTra9, _props$performanceTra10;
     if (props !== null && props !== void 0 && (_props$performanceTra9 = props.performanceTracking) !== null && _props$performanceTra9 !== void 0 && (_props$performanceTra10 = _props$performanceTra9.contentRetrievalTracking) !== null && _props$performanceTra10 !== void 0 && _props$performanceTra10.enabled) {
       const DEFAULT_SAMPLING_RATE = 100;
       const getValue = editorActions.getValue.bind(editorActions);
       if (!editorActions._contentRetrievalTracking) {
         editorActions._contentRetrievalTracking = {
           samplingCounters: {
@@ -193,21 +162,17 @@ export default class Editor extends React.Component {
           getValueTracked: false
         };
       }
       const {
         _contentRetrievalTracking: {
           samplingCounters,
           getValueTracked
         }
       } = editorActions;
       if (!getValueTracked) {
         const getValueWithTracking = async () => {
           try {
             var _props$performanceTra11, _props$performanceTra12, _props$performanceTra13;
             const value = await getValue();
             if (samplingCounters.success === ((_props$performanceTra11 = props === null || props === void 0 ? void 0 : (_props$performanceTra12 = props.performanceTracking) === null || _props$performanceTra12 === void 0 ? void 0 : (_props$performanceTra13 = _props$performanceTra12.contentRetrievalTracking) === null || _props$performanceTra13 === void 0 ? void 0 : _props$performanceTra13.successSamplingRate) !== null && _props$performanceTra11 !== void 0 ? _props$performanceTra11 : DEFAULT_SAMPLING_RATE)) {
               this.handleAnalyticsEvent({
                 payload: {
@@ -221,15 +186,12 @@ export default class Editor extends React.Component {
               });
               samplingCounters.success = 0;
             }
             samplingCounters.success++;
             return value;
           } catch (err) {
             var _props$performanceTra14, _props$performanceTra15, _props$performanceTra16;
             if (samplingCounters.failure === ((_props$performanceTra14 = props === null || props === void 0 ? void 0 : (_props$performanceTra15 = props.performanceTracking) === null || _props$performanceTra15 === void 0 ? void 0 : (_props$performanceTra16 = _props$performanceTra15.contentRetrievalTracking) === null || _props$performanceTra16 === void 0 ? void 0 : _props$performanceTra16.failureSamplingRate) !== null && _props$performanceTra14 !== void 0 ? _props$performanceTra14 : DEFAULT_SAMPLING_RATE)) {
               var _props$performanceTra17, _props$performanceTra18;
               this.handleAnalyticsEvent({
                 payload: {
                   action: ACTION.EDITOR_CONTENT_RETRIEVAL_PERFORMED,
@@ -244,47 +206,36 @@ export default class Editor extends React.Component {
               });
               samplingCounters.failure = 0;
             }
             samplingCounters.failure++;
             throw err;
           }
         };
         editorActions.getValue = getValueWithTracking;
         editorActions._contentRetrievalTracking.getValueTracked = true;
       }
     }
     return editorActions;
   }
   onEditorCreated(instance) {
     var _this$props$featureFl2;
     this.registerEditorForActions(instance.view, instance.eventDispatcher, instance.transformer);
     if ((_this$props$featureFl2 = this.props.featureFlags) !== null && _this$props$featureFl2 !== void 0 && _this$props$featureFl2.ufo) {
       this.experienceStore = ExperienceStore.getInstance(instance.view);
       this.experienceStore.start(EditorExperience.loadEditor, this.startTime);
     }
     if (this.props.onEditorReady) {
       var _this$props2, _this$props2$performa, _this$props2$performa2, _this$props$featureFl3;
       const measureEditorReady = ((_this$props2 = this.props) === null || _this$props2 === void 0 ? void 0 : (_this$props2$performa = _this$props2.performanceTracking) === null || _this$props2$performa === void 0 ? void 0 : (_this$props2$performa2 = _this$props2$performa.onEditorReadyCallbackTracking) === null || _this$props2$performa2 === void 0 ? void 0 : _this$props2$performa2.enabled) || ((_this$props$featureFl3 = this.props.featureFlags) === null || _this$props$featureFl3 === void 0 ? void 0 : _this$props$featureFl3.ufo);
       measureEditorReady && startMeasure(measurements.ON_EDITOR_READY_CALLBACK);
       this.props.onEditorReady(this.editorActions);
       measureEditorReady && stopMeasure(measurements.ON_EDITOR_READY_CALLBACK, this.sendDurationAnalytics(ACTION.ON_EDITOR_READY_CALLBACK));
     }
   }
   sendDurationAnalytics(action) {
     return async (duration, startTime) => {
       var _this$props$featureFl4;
       const contextIdentifier = await this.props.contextIdentifierProvider;
       const objectId = contextIdentifier === null || contextIdentifier === void 0 ? void 0 : contextIdentifier.objectId;
       if (this.createAnalyticsEvent) {
         fireAnalyticsEvent(this.createAnalyticsEvent)({
           payload: {
@@ -299,10 +250,8 @@ export default class Editor extends React.Component {
           }
         });
       }
       if ((_this$props$featureFl4 = this.props.featureFlags) !== null && _this$props$featureFl4 !== void 0 && _this$props$featureFl4.ufo) {
         var _this$experienceStore4, _this$experienceStore5;
         (_this$experienceStore4 = this.experienceStore) === null || _this$experienceStore4 === void 0 ? void 0 : _this$experienceStore4.mark(EditorExperience.loadEditor, action, startTime + duration);
         (_this$experienceStore5 = this.experienceStore) === null || _this$experienceStore5 === void 0 ? void 0 : _this$experienceStore5.addMetadata(EditorExperience.loadEditor, {
           objectId
@@ -310,14 +259,11 @@ export default class Editor extends React.Component {
       }
     };
   }
   deprecationWarnings(props) {
     var _props$allowTextColor;
     if (process.env.NODE_ENV === 'production') {
       return;
     }
     const nextVersion = nextMajorVersion();
     const deprecatedProperties = {
       allowTasksAndDecisions: {
@@ -336,44 +282,37 @@ export default class Editor extends React.Component {
     Object.keys(deprecatedProperties).forEach(property => {
       if (props.hasOwnProperty(property)) {
         const meta = deprecatedProperties[property];
-        const type = meta.type || 'enabled by default'; // eslint-disable-next-line no-console
+        const type = meta.type || 'enabled by default';
+        // eslint-disable-next-line no-console
         console.warn(`${property} property is deprecated. ${meta.message || ''} [Will be ${type} in editor-core@${nextVersion}]`);
       }
     });
     if (props.hasOwnProperty('allowTables') && typeof props.allowTables !== 'boolean' && (!props.allowTables || !props.allowTables.advanced)) {
       // eslint-disable-next-line no-console
       console.warn(`Advanced table options are deprecated (except isHeaderRowRequired) to continue using advanced table features use - <Editor allowTables={{ advanced: true }} /> [Will be changed in editor-core@${nextVersion}]`);
     }
     if (props.hasOwnProperty('allowTextColor') && typeof props.allowTextColor !== 'boolean' && (props === null || props === void 0 ? void 0 : (_props$allowTextColor = props.allowTextColor) === null || _props$allowTextColor === void 0 ? void 0 : _props$allowTextColor.allowMoreTextColors) !== undefined) {
       // eslint-disable-next-line no-console
       console.warn(`"allowMoreTextColors" field of "allowTextColor" property is deprecated. It will be removedin editor-core@${nextVersion}. The color palette now shows more colors by default.`);
     }
   }
   onEditorDestroyed(_instance) {
     this.unregisterEditorFromActions();
     if (this.props.onDestroy) {
       this.props.onDestroy();
     }
   }
   registerEditorForActions(editorView, eventDispatcher, contentTransformer) {
     this.editorActions._privateRegisterEditor(editorView, eventDispatcher, contentTransformer);
   }
   unregisterEditorFromActions() {
     if (this.editorActions) {
       this.editorActions._privateUnregisterEditor();
     }
   }
   handleProviders(props) {
     var _linking$smartLinks;
     const {
       emojiProvider,
       mentionProvider,
@@ -408,31 +347,25 @@ export default class Editor extends React.Component {
     this.providerFactory.setProvider('presenceProvider', presenceProvider);
     this.providerFactory.setProvider('macroProvider', macroProvider);
     const cardProvider = (linking === null || linking === void 0 ? void 0 : (_linking$smartLinks = linking.smartLinks) === null || _linking$smartLinks === void 0 ? void 0 : _linking$smartLinks.provider) || smartLinks && smartLinks.provider || UNSAFE_cards && UNSAFE_cards.provider;
     if (cardProvider) {
       this.providerFactory.setProvider('cardProvider', cardProvider);
     }
     this.providerFactory.setProvider('autoformattingProvider', autoformattingProvider);
     if (extensionProvider) {
       this.providerFactory.setProvider('extensionProvider', Promise.resolve(extensionProvider));
     }
     if (quickInsertProvider) {
       this.providerFactory.setProvider('quickInsertProvider', quickInsertProvider);
     }
   }
   getBaseFontSize() {
     return !['comment', 'chromeless', 'mobile'].includes(this.props.appearance) ? akEditorFullPageDefaultFontSize : undefined;
   }
   render() {
     var _this$props$performan3, _this$props$performan4;
     const Component = getUiComponent(this.props.appearance);
-    const overriddenEditorProps = { ...this.props,
+    const overriddenEditorProps = {
+      ...this.props,
       onSave: this.props.onSave ? this.handleSave : undefined,
       // noop all analytic events, even if a handler is still passed.
       analyticsHandler: undefined
@@ -485,7 +418,6 @@ export default class Editor extends React.Component {
             editorRef
           }) => {
             var _this$props$featureFl5, _this$props$featureFl6;
             return jsx(BaseTheme, {
               baseFontSize: this.getBaseFontSize()
             }, jsx(Component, {
@@ -527,9 +459,7 @@ export default class Editor extends React.Component {
       }))))))
     }));
   }
 }
 _defineProperty(Editor, "defaultProps", {
   appearance: 'comment',
   disabled: false,
@@ -538,7 +468,6 @@ _defineProperty(Editor, "defaultProps", {
   allowNewInsertionBehaviour: true,
   quickInsert: true
 });
 _defineProperty(Editor, "propTypes", {
   minHeight: ({
     appearance,
@@ -547,11 +476,9 @@ _defineProperty(Editor, "propTypes", {
     if (minHeight && appearance && !['comment', 'chromeless'].includes(appearance)) {
       return new Error('minHeight only supports editor appearance chromeless and comment');
     }
     return null;
   }
 });
 _defineProperty(Editor, "contextTypes", {
   editorActions: PropTypes.object
 });

package/dist/es2019/extensibility.js CHANGED Viewed

@@ -5,11 +5,11 @@ export { default as Extension } from './plugins/extension/ui/Extension';
 export { default as ExtensionNodeWrapper } from './plugins/extension/ui/Extension/ExtensionNodeWrapper';
 export { ExtensionNode } from './plugins/extension/nodeviews/extension';
 import { pluginKey as tablePluginKeyInner } from '@atlaskit/editor-plugin-table/plugin-key';
 /**
  * @deprecated [ED-14688] - used during the table viz project and not used anymore
  * will be removed in a future version of `@atlaskit/editor-core`
  */
 const tablePluginKey = tablePluginKeyInner;
 export { tablePluginKey };
 export const EmitterEvents = {

package/dist/es2019/index.js CHANGED Viewed

@@ -41,13 +41,15 @@ export { pluginKey as quickInsertPluginKey, memoProcessItems as processQuickInse
 export { insertLink, insertLinkWithAnalyticsMobileNative, insertLinkWithAnalytics, isTextAtPos, isLinkAtPos, updateLink } from './plugins/hyperlink/commands';
 export { historyPluginKey } from './plugins/history';
 export { INPUT_METHOD, ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from './plugins/analytics';
-export { setKeyboardHeight, setMobilePaddingTop, setIsExpanded } from './plugins/mobile-dimensions/commands'; // Used in editor-test-helpers and mobile bridge
+export { setKeyboardHeight, setMobilePaddingTop, setIsExpanded } from './plugins/mobile-dimensions/commands';
+// Used in editor-test-helpers and mobile bridge
 export { setTextSelection, dedupe, getNodesCount, measurements, hasVisibleContent, isEmptyDocument } from './utils';
 export { getListCommands } from './utils/list-commands';
 export { ReactEditorView, BaseReactEditorView } from './create-editor';
 export { getDefaultPresetOptionsFromEditorProps } from './create-editor';
-export { default as EditorActions } from './actions'; // Re-export from provider factory to not cause a breaking change
+export { default as EditorActions } from './actions';
+// Re-export from provider factory to not cause a breaking change
 export { PortalProvider, PortalProviderAPI, PortalRenderer } from './ui/PortalProvider';
 export { GapCursorSelection, Side as GapCursorSide } from './plugins/selection/gap-cursor-selection';

package/dist/es2019/insert-api/api.js CHANGED Viewed

@@ -10,11 +10,9 @@ export const createInsertNodeAPI = ({
       options
     }) => {
       const editorView = getEditorView();
       if (!editorView) {
         return false;
       }
       const {
         state: {
           tr
@@ -25,19 +23,20 @@ export const createInsertNodeAPI = ({
         editorPlugins,
         node,
         options
-      })(tr); // TODO: ED-14676 This approach to send analytics should be temporary only for the table work
+      })(tr);
+      // TODO: ED-14676 This approach to send analytics should be temporary only for the table work
       if (options.analyticsPayload) {
         addAnalytics(editorView.state, tr, options.analyticsPayload);
       }
       editorView.dispatch(tr);
       return true;
-    } // TODO: ED-14676 - Implement the append behavior
+    }
+    // TODO: ED-14676 - Implement the append behavior
     // append: ({ node, options }) => (tr) => {
     //   const editorPlugins = getEditorPlugins();
     //   return insertContent({ editorPlugins, node, options })(tr);
     // },
   };
 };

package/dist/es2019/insert-api/insert-content-handlers.js CHANGED Viewed

@@ -4,22 +4,19 @@ export const findCreateNodeHandler = ({
   editorPlugins
 }) => {
   var _editorPluginHandler$;
   if (!node) {
     return null;
   }
   const nodeName = typeof node === 'string' ? node : null;
   const editorPluginHandler = nodeName ? editorPlugins.find(plugin => {
     if (!plugin.nodes) {
       return false;
     }
     return plugin.nodes().find(nodeConfig => nodeConfig.name === nodeName);
-  }) : null; // That is how we allow the insertion behavior to be extended. (for now)
+  }) : null;
+  // That is how we allow the insertion behavior to be extended. (for now)
   // Any plugin, following the rank order and respecting the node name, can override the node insertion output.
   // To guarantee an insertion
   return (editorPluginHandler === null || editorPluginHandler === void 0 ? void 0 : (_editorPluginHandler$ = editorPluginHandler.pluginsOptions) === null || _editorPluginHandler$ === void 0 ? void 0 : _editorPluginHandler$.createNodeHandler) || null;
 };
 export const handleInsertContent = ({
@@ -33,7 +30,9 @@ export const handleInsertContent = ({
     node,
     editorPlugins
   });
-  const nodeName = typeof node === 'string' ? node : null; //  TODO: ED-14676 Once we fix the coupled table code issue (ED-15503) we should enable this API to insert any ProseMirror Node
+  const nodeName = typeof node === 'string' ? node : null;
+  //  TODO: ED-14676 Once we fix the coupled table code issue (ED-15503) we should enable this API to insert any ProseMirror Node
   //  if (node instanceof PMNode || node instanceof Fragment) {
   //    insertProseMirrorContent({
   //      tr,
@@ -56,11 +55,9 @@ export const handleInsertContent = ({
     });
   } else if (nodeName) {
     const nodeType = tr.doc.type.schema.nodes[nodeName];
     if (!nodeType) {
       return false;
     }
     insertProseMirrorContent({
       tr,
       node: nodeType.createAndFill(),
@@ -69,17 +66,19 @@ export const handleInsertContent = ({
     });
   } else {
     return false;
-  } // TODO: ED-14676  Implement the attachPluginMessage behavior
+  }
+  // TODO: ED-14676  Implement the attachPluginMessage behavior
   // if (editorPluginHandler?.nodes && options.attachPluginMessage) {
   //   const pluginKey = editorPluginHandler
   //     .nodes()
   //     .find((nodeConfig) => nodeConfig.name === nodeName)?.pluginKey;
   //   if (pluginKey) {
   //     tr.setMeta(pluginKey, options.attachPluginMessage);
   //   }
   // }
   tr.scrollIntoView();
   return true;
 };

package/dist/es2019/insert-api/insert-node-helpers.js CHANGED Viewed

@@ -3,18 +3,18 @@ import { TextSelection, NodeSelection } from 'prosemirror-state';
 import { Node as PMNode, Slice, Fragment } from 'prosemirror-model';
 import { normaliseNestedLayout } from '../utils/selection';
 import { safeInsert } from '../utils/insert';
 function findInsertPoint(doc, pos, nodeToInsert) {
   const $pos = doc.resolve(pos);
   const createInsertPosition = (from, to) => ({
     from,
     to: to || from
-  }); // Search for a valid position for nodeToInsert in progressively higher levels
+  });
+  // Search for a valid position for nodeToInsert in progressively higher levels
   for (let level = $pos.depth; level >= 0; level--) {
-    const nodeAtLevel = $pos.node(level); // Try to replace the empty paragraph in the level above
+    const nodeAtLevel = $pos.node(level);
+    // Try to replace the empty paragraph in the level above
     // Scenario:
     //   doc(
     //     table(
@@ -25,38 +25,33 @@ function findInsertPoint(doc, pos, nodeToInsert) {
     //       )
     //     )
     //   )
     const levelAbove = Math.max(level - 1, 0);
-    const parentNode = $pos.node(levelAbove); // Special case: when this is true, the 'to' position should be the end
+    const parentNode = $pos.node(levelAbove);
+    // Special case: when this is true, the 'to' position should be the end
     // of the empty paragraph
     const isNodeAtLevelEmptyParagraph = nodeAtLevel.type.name === 'paragraph' && nodeAtLevel.content.size === 0;
     const indexAtLevelAbove = $pos.index(levelAbove);
     const canReplaceNodeAtLevelAbove = parentNode.canReplaceWith(indexAtLevelAbove, indexAtLevelAbove, nodeToInsert.type);
     if (isNodeAtLevelEmptyParagraph && canReplaceNodeAtLevelAbove) {
       const from = $pos.posAtIndex(indexAtLevelAbove, levelAbove);
       return createInsertPosition(from, from + nodeAtLevel.nodeSize);
-    } // Try to insert this node right after the node in the level above
+    }
+    // Try to insert this node right after the node in the level above
     // Scenario:
     //   doc(
     //     panel(
     //       p('{<>}'),
     //     )
     //   )
     const indexAfterAtLevelAbove = $pos.indexAfter(levelAbove);
     const canInsertNodeAtLevelAbove = parentNode.canReplaceWith(indexAfterAtLevelAbove, indexAfterAtLevelAbove, nodeToInsert.type);
     if (canInsertNodeAtLevelAbove) {
       return createInsertPosition($pos.posAtIndex(indexAfterAtLevelAbove, levelAbove));
     }
   }
   return createInsertPosition(0);
 }
 export const insertBlockNode = ({
   node,
   tr,
@@ -70,22 +65,19 @@ export const insertBlockNode = ({
       pos: end
     }
   } = position;
   if (node.isText) {
     return tr.replaceWith(start, end, node);
   }
   if (node.isBlock) {
     tr.delete(start, end);
     const mappedStart = tr.mapping.map(start);
-    const nodeNormalized = normaliseNestedLayout(tr, node); // Handle edge cases for hr and mediaSingle
+    const nodeNormalized = normaliseNestedLayout(tr, node);
+    // Handle edge cases for hr and mediaSingle
     const inserted = safeInsert(nodeNormalized, mappedStart)(tr);
     if (inserted) {
       return tr;
     }
     const sliceInserted = Slice.maxOpen(Fragment.from(nodeNormalized));
     const {
       from,
@@ -95,12 +87,10 @@ export const insertBlockNode = ({
     const openPosition = Math.min(from + (node.isAtom ? node.nodeSize : sliceInserted.openStart), tr.doc.content.size);
     const FORWARD_DIRECTION = 1;
     const nextSelection = TextSelection.findFrom(tr.doc.resolve(openPosition), FORWARD_DIRECTION, true);
     if (nextSelection) {
       return tr.setSelection(nextSelection);
     }
   }
   return tr;
 };
 export const insertInlineNodeOrFragment = ({
@@ -119,11 +109,9 @@ export const insertInlineNodeOrFragment = ({
   } = position;
   const fragment = maybeFragment instanceof PMNode ? Fragment.from(maybeFragment) : maybeFragment;
   tr.replaceWith(start, end, fragment);
   if (selectInlineNode) {
     return tr.setSelection(NodeSelection.create(tr.doc, start));
   }
   return tr.setSelection(TextSelection.near(tr.doc.resolve(start + fragment.size)));
 };
 export const insertProseMirrorContent = ({