@atlaskit/editor-common 74.0.0 → 74.1.0

package/dist/es2019/insert/index.js

@@ -0,0 +1,264 @@
+import { Fragment, Node, Slice } from 'prosemirror-model';
+import { NodeSelection, Selection, TextSelection } from 'prosemirror-state';
+import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
+import { canInsert, findParentNodeOfType, hasParentNodeOfType, isNodeSelection, safeInsert as pmSafeInsert } from 'prosemirror-utils';
+import { GapCursorSelection, Side } from '../selection';
+import { isEmptyParagraph, isListItemNode } from '../utils';
+export let LookDirection = /*#__PURE__*/function (LookDirection) {
+  LookDirection["Before"] = "before";
+  LookDirection["After"] = "after";
+  return LookDirection;
+}({});
+export const normaliseNestedLayout = ({
+  selection,
+  doc
+}, node) => {
+  if (selection.$from.depth > 1) {
+    if (node.attrs.layout && node.attrs.layout !== 'default') {
+      return node.type.createChecked({
+        ...node.attrs,
+        layout: 'default'
+      }, node.content, node.marks);
+    }
+
+    // If its a breakout layout, we can remove the mark
+    // Since default isn't a valid breakout mode.
+    const breakoutMark = doc.type.schema.marks.breakout;
+    if (breakoutMark && breakoutMark.isInSet(node.marks)) {
+      const newMarks = breakoutMark.removeFromSet(node.marks);
+      return node.type.createChecked(node.attrs, node.content, newMarks);
+    }
+  }
+  return node;
+};
+const isLastChild = ($pos, doc) => doc.resolve($pos.after()).node().lastChild === $pos.node();
+const isFirstChild = ($pos, doc) => doc.resolve($pos.before()).node().firstChild === $pos.node();
+const nodeIsInsideAList = tr => {
+  const {
+    nodes
+  } = tr.doc.type.schema;
+  return hasParentNodeOfType([nodes.orderedList, nodes.bulletList])(tr.selection);
+};
+const selectionIsInsideAPanel = tr => {
+  const {
+    nodes
+  } = tr.doc.type.schema;
+  return hasParentNodeOfType(nodes.panel)(tr.selection);
+};
+const selectionIsInNestedList = tr => {
+  const {
+    nodes
+  } = tr.doc.type.schema;
+  const parentListNode = findParentNodeOfType([nodes.orderedList, nodes.bulletList])(tr.selection);
+  if (!parentListNode) {
+    return false;
+  }
+  return isListItemNode(tr.doc.resolve(parentListNode.pos).parent);
+};
+const insertBeforeOrAfter = (tr, lookDirection, $parentPos, $proposedPosition, content) => {
+  /**
+   * This block caters for the first item in a parent with the cursor being at the very start
+   * or the last item with the cursor being at the very end
+   *
+   * e.g.
+   * ul
+   *  li {<>}Scenario one
+   *  li
+   *  li Scenario two{<>}
+   */
+
+  if (isFirstChild($proposedPosition, tr.doc) && lookDirection === LookDirection.Before || isLastChild($proposedPosition, tr.doc) && lookDirection === LookDirection.After) {
+    return tr.insert($parentPos[lookDirection](), content);
+  }
+  return tr.insert($proposedPosition[lookDirection](), content);
+};
+
+// FIXME: A more sustainable and configurable way to choose when to split
+const shouldSplit = (nodeType, schemaNodes) => {
+  return [schemaNodes.bulletList, schemaNodes.orderedList, schemaNodes.panel].includes(nodeType);
+};
+export const safeInsert = (content, position) => tr => {
+  var _tr$selection$$from$n;
+  const {
+    nodes
+  } = tr.doc.type.schema;
+  const whitelist = [nodes.rule, nodes.mediaSingle];
+  if (content instanceof Fragment || !whitelist.includes(content.type)) {
+    return null;
+  }
+
+  // Check for selection
+  if (!tr.selection.empty || isNodeSelection(tr.selection)) {
+    // NOT IMPLEMENTED
+    return null;
+  }
+  const {
+    $from
+  } = tr.selection;
+  const $insertPos = position ? tr.doc.resolve(position) : isNodeSelection(tr.selection) ? tr.doc.resolve($from.pos + 1) : $from;
+  let lookDirection;
+  const insertPosEnd = $insertPos.end();
+  const insertPosStart = $insertPos.start();
+
+  // When parent node is an empty paragraph,
+  // check the empty paragraph is the first or last node of its parent.
+  if (isEmptyParagraph($insertPos.parent)) {
+    if (isLastChild($insertPos, tr.doc)) {
+      lookDirection = LookDirection.After;
+    } else if (isFirstChild($insertPos, tr.doc)) {
+      lookDirection = LookDirection.Before;
+    }
+  } else {
+    if ($insertPos.pos === insertPosEnd) {
+      lookDirection = LookDirection.After;
+    } else if ($insertPos.pos === insertPosStart) {
+      lookDirection = LookDirection.Before;
+    }
+  }
+  const grandParentNodeType = (_tr$selection$$from$n = tr.selection.$from.node(-1)) === null || _tr$selection$$from$n === void 0 ? void 0 : _tr$selection$$from$n.type;
+  const parentNodeType = tr.selection.$from.parent.type;
+
+  // if there is no direction, and cannot split for this particular node
+  const noDirectionAndShouldNotSplit = !lookDirection && !shouldSplitSelectedNodeOnNodeInsertion({
+    parentNodeType,
+    grandParentNodeType,
+    content
+  });
+  const ruleNodeInANestedListNode = content.type === nodes.rule && selectionIsInNestedList(tr);
+  const nonRuleNodeInListNode = !(content.type === nodes.rule) && nodeIsInsideAList(tr);
+  if (ruleNodeInANestedListNode || noDirectionAndShouldNotSplit && nonRuleNodeInListNode || noDirectionAndShouldNotSplit && !nodeIsInsideAList(tr)) {
+    // node to be inserted is an invalid child of selection so insert below selected node
+    return pmSafeInsert(content, tr.selection.from)(tr);
+  }
+
+  // if node is a rule and that is a flat list splitting and not at the end of a list
+  const {
+    from,
+    to
+  } = tr.selection;
+  const ruleTypeInAList = content.type === nodes.rule && nodeIsInsideAList(tr);
+  if (ruleTypeInAList && !($insertPos.pos === insertPosEnd)) {
+    return tr.replaceRange(from, to, new Slice(Fragment.from(nodes.rule.createChecked()), 0, 0));
+  }
+  if (!lookDirection) {
+    // fallback to consumer for now
+    return null;
+  }
+
+  // Replace empty paragraph
+  if (isEmptyParagraph($insertPos.parent) && canInsert(tr.doc.resolve($insertPos[lookDirection]()), content)) {
+    return finaliseInsert(tr.replaceWith($insertPos.before(), $insertPos.after(), content), -1);
+  }
+  let $proposedPosition = $insertPos;
+  while ($proposedPosition.depth > 0) {
+    const $parentPos = tr.doc.resolve($proposedPosition[lookDirection]());
+    const parentNode = $parentPos.node();
+
+    // Insert at position (before or after target pos)
+    if (canInsert($proposedPosition, content)) {
+      return finaliseInsert(tr.insert($proposedPosition.pos, content), content.nodeSize);
+    }
+
+    // If we can't insert, and we think we should split, we fallback to consumer for now
+    if (shouldSplit(parentNode.type, tr.doc.type.schema.nodes)) {
+      const nextTr = finaliseInsert(insertBeforeOrAfter(tr, lookDirection, $parentPos, $proposedPosition, content), content.nodeSize);
+
+      // Move selection to the closest text node, otherwise it defaults to the whatever the lookDirection is set to above
+      if ([nodes.orderedList, nodes.bulletList].includes(parentNode.type) && nextTr) {
+        return nextTr.setSelection(TextSelection.between(nextTr.selection.$from, nextTr.selection.$from));
+      } else {
+        return nextTr;
+      }
+    }
+
+    // Can not insert into current parent, step up one parent
+    $proposedPosition = $parentPos;
+  }
+  return finaliseInsert(tr.insert($proposedPosition.pos, content), content.nodeSize);
+};
+const finaliseInsert = (tr, nodeLength) => {
+  const lastStep = tr.steps[tr.steps.length - 1];
+  if (!(lastStep instanceof ReplaceStep || lastStep instanceof ReplaceAroundStep)) {
+    return null;
+  }
+
+  // Place gap cursor after the newly inserted node
+  const gapCursorPos = lastStep.to + lastStep.slice.openStart + nodeLength;
+  return tr.setSelection(new GapCursorSelection(tr.doc.resolve(gapCursorPos), Side.RIGHT)).scrollIntoView();
+};
+
+/**
+ * Method extracted from typeahed plugin to be shared with the element browser on handling element insertion.
+ */
+export const insertSelectedItem = (maybeNode, opts = {}) => (state, tr, start) => {
+  if (!maybeNode) {
+    return tr;
+  }
+  const isInputFragment = maybeNode instanceof Fragment;
+  let node;
+  try {
+    node = maybeNode instanceof Node || isInputFragment ? maybeNode : typeof maybeNode === 'string' ? state.schema.text(maybeNode) : Node.fromJSON(state.schema, maybeNode);
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    return tr;
+  }
+  if (node.isText) {
+    tr = tr.replaceWith(start, start, node);
+
+    /**
+     *
+     * Replacing a type ahead query mark with a block node.
+     *
+     */
+  } else if (node.isBlock) {
+    /**
+     *
+     * Rule has unique insertion behaviour
+     * so using this safeInsert function in order to handle specific cases in flat list vs nested list
+     * instead of a generic pmSafeInsert (i.e appending at the end)
+     *
+     */
+
+    const selectionInsideAPanel = selectionIsInsideAPanel(tr);
+    if (node.type.name === 'rule' && !selectionInsideAPanel) {
+      var _safeInsert;
+      tr = (_safeInsert = safeInsert(node, tr.selection.from)(tr)) !== null && _safeInsert !== void 0 ? _safeInsert : tr;
+    } else {
+      tr = pmSafeInsert(normaliseNestedLayout(state, node), undefined, true)(tr);
+    }
+
+    /**
+     *
+     * Replacing a type ahead query mark with an inline node.
+     *
+     */
+  } else if (node.isInline || isInputFragment) {
+    const fragment = isInputFragment ? node : Fragment.fromArray([node, state.schema.text(' ')]);
+    tr = tr.replaceWith(start, start, fragment);
+    if (opts.selectInlineNode) {
+      // Select inserted node
+      tr = tr.setSelection(NodeSelection.create(tr.doc, start));
+    } else {
+      // Placing cursor after node + space.
+      tr = tr.setSelection(Selection.near(tr.doc.resolve(start + fragment.size)));
+    }
+  }
+  return tr;
+};
+
+/**
+ * ED-14584: Util to check if the destination node is a paragraph & the
+ * content being inserted is a valid child of the grandparent node.
+ * In this case, the destination node should split
+ */
+export const shouldSplitSelectedNodeOnNodeInsertion = ({
+  parentNodeType,
+  grandParentNodeType,
+  content
+}) => {
+  if (parentNodeType.name === 'doc' || parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(Fragment.from(content))) {
+    return true;
+  }
+  return false;
+};

package/dist/es2019/monitoring/error.js

@@ -0,0 +1,68 @@
+const SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
+const packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
+const packageVersion = "74.1.0";
+const sanitiseSentryEvents = (data, _hint) => {
+  // Remove URL as it has UGC
+  // TODO: Sanitise the URL instead of just removing it
+  if (data.request) {
+    delete data.request.url;
+  }
+  return data;
+};
+export const logException = async (error, tags) => {
+  try {
+    var _process$env$CLOUD_EN;
+    // We don't want to log exceptions for branch deploys or in development / test scenarios
+    if (process.env.NODE_ENV !== 'production' || process.env.CLOUD_ENV === 'branch') {
+      return;
+    }
+    const {
+      BrowserClient,
+      defaultIntegrations,
+      getCurrentHub
+    } = await import( /* webpackChunkName: "@atlaskit-internal_editor-sentrybrowser" */'@sentry/browser');
+    const {
+      ExtraErrorData
+    } = await import( /* webpackChunkName: "@atlaskit-internal_editor-sentryintegrations" */'@sentry/integrations');
+    const sentryOptions = {
+      dsn: SENTRY_DSN,
+      release: `${packageName}@${packageVersion}`,
+      environment: (_process$env$CLOUD_EN = process.env.CLOUD_ENV) !== null && _process$env$CLOUD_EN !== void 0 ? _process$env$CLOUD_EN : 'unknown',
+      ignoreErrors: [
+      // Network issues
+      /^network error/i, /^network failure/i, 'TypeError: Failed to fetch',
+      // A benign error, see https://stackoverflow.com/a/50387233/2645305
+      'ResizeObserver loop limit exceeded', /ResizeObserver loop completed with undelivered notifications/],
+      autoSessionTracking: false,
+      integrations: _integrations => [
+      // Remove the Breadcrumbs integration from the default as it's too likely to log UGC/PII
+      // https://docs.sentry.io/platforms/javascript/configuration/integrations/default/
+      ...defaultIntegrations.filter(({
+        name
+      }) => name !== 'Breadcrumbs'),
+      // Extracts all non-native attributes from the error object and attaches them to the event as the extra data
+      // https://docs.sentry.io/platforms/javascript/configuration/integrations/plugin/?original_referrer=https%3A%2F%2Fduckduckgo.com%2F#extraerrordata
+      new ExtraErrorData()],
+      beforeSend: sanitiseSentryEvents
+    };
+    // Use a client to avoid picking up the errors from parent applications
+    const client = new BrowserClient(sentryOptions);
+    const hub = getCurrentHub();
+    hub.bindClient(client);
+    hub.withScope(scope => {
+      scope.setTags({
+        // Jira environment variables
+        'jira-bundler': window.BUNDLER_VERSION,
+        'jira-variant': window.BUILD_VARIANT,
+        'jira-release': window.BUILD_KEY,
+        // Confluence environment variables
+        'confluence-frontend-version': window.__buildInfo.FRONTEND_VERSION,
+        ...tags
+      });
+      hub.captureException(error);
+    });
+    return client.close();
+  } catch (_error) {
+    // Error reporting failed, we don't want this to generate more errors
+  }
+};

package/dist/es2019/monitoring/index.js

@@ -0,0 +1 @@
+export { logException } from './error';

package/dist/es2019/node-width/index.js

@@ -1,5 +1,6 @@
 import { findParentNodeOfTypeClosestToPos } from 'prosemirror-utils';
 import { akEditorFullWidthLayoutWidth, akLayoutGutterOffset, gridMediumMaxWidth } from '@atlaskit/editor-shared-styles';
+// eslint-disable-next-line @atlaskit/design-system/no-deprecated-imports
 import { gridSize } from '@atlaskit/theme/constants';
 import { BODIED_EXT_PADDING } from '../styles/shared/extension';
 import { LAYOUT_COLUMN_PADDING, LAYOUT_SECTION_MARGIN } from '../styles/shared/layout';
@@ -49,6 +50,9 @@ export const getParentNodeWidth = (pos, state, containerWidth, isFullWidthModeEn
     case schema.nodes.bodiedExtension:
       parentWidth -= BODIED_EXT_PADDING * 2;
       break;
+
+    // TODO: Migrate away from gridSize
+    // Recommendation: Replace gridSize with 8
     case schema.nodes.expand:
       // padding
       parentWidth -= gridSize() * 2;

package/dist/es2019/paste/index.js

@@ -0,0 +1 @@
+export { md } from './md';

package/dist/es2019/paste/md-plugins/ignore-list-heading-md-plugin.js

@@ -0,0 +1,43 @@
+/*
+ * ED-15646
+ * Headings in list items are not supported in our schema.
+ * As the markdown transformer is used by the paste plugin,
+ * certain pastes will strip invalid lines as
+ * prosemirror-markdown cannot conform to the schema
+ */
+
+function handleHeadingOpen(state, token, acc, index) {
+  var _state$tokens;
+  const isInListItem = ((_state$tokens = state.tokens[index - 1]) === null || _state$tokens === void 0 ? void 0 : _state$tokens.type) === 'list_item_open';
+  if (isInListItem) {
+    acc.push(new state.Token('paragraph_open', 'p', 1));
+  } else {
+    acc.push(token);
+  }
+}
+function handleHeadingClose(state, token, acc, index) {
+  var _state$tokens2;
+  const isInListItem = ((_state$tokens2 = state.tokens[index + 1]) === null || _state$tokens2 === void 0 ? void 0 : _state$tokens2.type) === 'list_item_close';
+  if (isInListItem) {
+    acc.push(new state.Token('paragraph_close', 'p', -1));
+  } else {
+    acc.push(token);
+  }
+}
+export default function (md) {
+  md.core.ruler.after('inline', 'ignore-list-heading-md-plugin', function (state) {
+    state.tokens = state.tokens.reduce((acc, token, index) => {
+      const {
+        type
+      } = token;
+      if (type === 'heading_open') {
+        handleHeadingOpen(state, token, acc, index);
+      } else if (type === 'heading_close') {
+        handleHeadingClose(state, token, acc, index);
+      } else {
+        acc.push(token);
+      }
+      return acc;
+    }, []);
+  });
+}

package/dist/es2019/paste/md-plugins/linkify-md-plugin.js

@@ -0,0 +1,128 @@
+// File has been copied to packages/editor/editor-plugin-ai/src/provider/markdown-transformer/md/linkify-md-plugin.ts
+// If changes are made to this file, please make the same update in the linked file.
+
+import LinkifyIt from 'linkify-it';
+import { linkifyMatch } from '@atlaskit/adf-schema';
+import { findFilepaths, isLinkInMatches } from '../../utils';
+
+// modified version of the original Linkify plugin
+// https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js
+const arrayReplaceAt = (src, pos, newElements) => {
+  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
+};
+const isLinkOpen = str => {
+  return /^<a[>\s]/i.test(str);
+};
+const isLinkClose = str => {
+  return /^<\/a\s*>/i.test(str);
+};
+const linkify = state => {
+  const blockTokens = state.tokens;
+  const linkify = new LinkifyIt();
+  for (let j = 0, l = blockTokens.length; j < l; j++) {
+    if (blockTokens[j].type !== 'inline' || !linkify.pretest(blockTokens[j].content)) {
+      continue;
+    }
+    let tokens = blockTokens[j].children;
+    let htmlLinkLevel = 0;
+
+    // We scan from the end, to keep position when new tags added.
+    // Use reversed logic in links start/end match
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      const currentToken = tokens[i];
+
+      // Skip content of markdown links
+      if (currentToken.type === 'link_close') {
+        i--;
+        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {
+          i--;
+        }
+        continue;
+      }
+
+      // Skip content of html tag links
+      if (currentToken.type === 'html_inline') {
+        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
+          htmlLinkLevel--;
+        }
+        if (isLinkClose(currentToken.content)) {
+          htmlLinkLevel++;
+        }
+      }
+      if (htmlLinkLevel > 0) {
+        continue;
+      }
+      if (currentToken.type === 'text' && linkify.test(currentToken.content)) {
+        const text = currentToken.content;
+        let links = linkifyMatch(text);
+        if (!links.length) {
+          links = linkify.match(text) || [];
+        }
+
+        // Now split string to nodes
+        const nodes = [];
+        let level = currentToken.level;
+        let lastPos = 0;
+        const filepaths = findFilepaths(text);
+        for (let ln = 0; ln < links.length; ln++) {
+          if (isLinkInMatches(links[ln].index, filepaths)) {
+            continue;
+          }
+          const {
+            url
+          } = links[ln];
+          const fullUrl = state.md.normalizeLink(url);
+          if (!state.md.validateLink(fullUrl)) {
+            continue;
+          }
+          let urlText = links[ln].text;
+
+          // Linkifier might send raw hostnames like "example.com", where url
+          // starts with domain name. So we prepend http:// in those cases,
+          // and remove it afterwards.
+          //
+          if (!links[ln].schema) {
+            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\/\//, '');
+          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
+            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');
+          } else {
+            urlText = state.md.normalizeLinkText(urlText);
+          }
+          const pos = links[ln].index;
+          if (pos > lastPos) {
+            const token = new state.Token('text', '', 0);
+            token.content = text.slice(lastPos, pos);
+            token.level = level;
+            nodes.push(token);
+          }
+          let token = new state.Token('link_open', 'a', 1);
+          token.attrs = [['href', fullUrl]];
+          token.level = level++;
+          token.markup = 'linkify';
+          token.info = 'auto';
+          nodes.push(token);
+          token = new state.Token('text', '', 0);
+          token.content = urlText;
+          token.level = level;
+          nodes.push(token);
+          token = new state.Token('link_close', 'a', -1);
+          token.level = --level;
+          token.markup = 'linkify';
+          token.info = 'auto';
+          nodes.push(token);
+          lastPos = links[ln].lastIndex;
+        }
+        if (lastPos < text.length) {
+          const token = new state.Token('text', '', 0);
+          token.content = text.slice(lastPos);
+          token.level = level;
+          nodes.push(token);
+        }
+
+        // replace current node
+        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);
+      }
+    }
+  }
+};
+export default (md => md.core.ruler.push('custom-linkify', linkify));

package/dist/es2019/paste/md-plugins/newline-md-plugin.js

@@ -0,0 +1,58 @@
+// File has been copied to packages/editor/editor-plugin-ai/src/provider/markdown-transformer/md/newline-md-plugin.ts
+// If changes are made to this file, please make the same update in the linked file.
+
+// ED-15363: modified version of the original newline plugin
+// https://github.com/markdown-it/markdown-it/blob/master/lib/rules_inline/newline.js
+const newline = (state, silent) => {
+  let pmax,
+    // ED-15363: unread variables
+    // max,
+    // ws,
+    pos = state.pos;
+  if (state.src.charCodeAt(pos) !== 0x0a /* \n */) {
+    return false;
+  }
+  pmax = state.pending.length - 1;
+  // ED-15363: unread variable
+  // max = state.posMax;
+
+  // '  \n' -> hardbreak
+  // Lookup in pending chars is bad practice! Don't copy to other rules!
+  // Pending string is stored in concat mode, indexed lookups will cause
+  // convertion to flat mode.
+  if (!silent) {
+    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {
+      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {
+        // ED-15363: We commented out this logic to preserve trailing whitespaces
+        // for each line of text when pasting plain text
+
+        // // Find whitespaces tail of pending chars.
+        // ws = pmax - 1;
+        // while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) {
+        //   ws--;
+        // }
+        // state.pending = state.pending.slice(0, ws);
+        state.push('hardbreak', 'br', 0);
+      } else {
+        state.pending = state.pending.slice(0, -1);
+        state.push('softbreak', 'br', 0);
+      }
+    } else {
+      state.push('softbreak', 'br', 0);
+    }
+  }
+  pos++;
+
+  // ED-15363: We commented out this logic from the original library to
+  // preserve leading whitespaces for each line of text when pasting plain
+  // text (to preserve whitespace-based indentation).
+
+  // // skip heading spaces for next line
+  // while (pos < max && isSpace(state.src.charCodeAt(pos))) {
+  //   pos++;
+  // }
+
+  state.pos = pos;
+  return true;
+};
+export default (md => md.inline.ruler.at('newline', newline));

package/dist/es2019/paste/md-plugins/paragraph-md-plugin.js

@@ -0,0 +1,64 @@
+// File has been copied to packages/editor/editor-plugin-ai/src/provider/markdown-transformer/md/paragraph-md-plugin.ts
+// If changes are made to this file, please make the same update in the linked file.
+
+// ED-15363: modified version of the original paragraph plugin
+// https://github.com/markdown-it/markdown-it/blob/master/lib/rules_block/paragraph.js
+
+const paragraph = (state, startLine) => {
+  let content,
+    terminate,
+    i,
+    l,
+    token,
+    oldParentType,
+    nextLine = startLine + 1,
+    terminatorRules = state.md.block.ruler.getRules('paragraph'),
+    endLine = state.lineMax;
+  oldParentType = state.parentType;
+  state.parentType = 'paragraph';
+
+  // jump line-by-line until empty one or EOF
+  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
+    // this would be a code block normally, but after paragraph
+    // it's considered a lazy continuation regardless of what's there
+    if (state.sCount[nextLine] - state.blkIndent > 3) {
+      continue;
+    }
+
+    // quirk for blockquotes, this line should already be checked by that rule
+    if (state.sCount[nextLine] < 0) {
+      continue;
+    }
+
+    // Some tags can terminate paragraph without empty line.
+    terminate = false;
+    for (i = 0, l = terminatorRules.length; i < l; i++) {
+      if (terminatorRules[i](state, nextLine, endLine, true)) {
+        terminate = true;
+        break;
+      }
+    }
+    if (terminate) {
+      break;
+    }
+  }
+
+  // ED-15363: We removed .trim() from this logic from the original library to
+  // preserve leading whitespaces at the beginning and end of paragraph blocks
+  // when pasting plain text (to preserve whitespace-based indentation, at the
+  // beginning and end of paragraphs).
+
+  // content = state.getLines(startLine, nextLine, state.blkIndent, false) .trim()
+  content = state.getLines(startLine, nextLine, state.blkIndent, false);
+  state.line = nextLine;
+  token = state.push('paragraph_open', 'p', 1);
+  token.map = [startLine, state.line];
+  token = state.push('inline', '', 0);
+  token.content = content;
+  token.map = [startLine, state.line];
+  token.children = [];
+  token = state.push('paragraph_close', 'p', -1);
+  state.parentType = oldParentType;
+  return true;
+};
+export default (md => md.block.ruler.at('paragraph', paragraph));

package/dist/es2019/paste/md.js

@@ -0,0 +1,22 @@
+// File has been copied to packages/editor/editor-plugin-ai/src/provider/markdown-transformer/md/index.ts
+// If changes are made to this file, please make the same update in the linked file.
+import MarkdownIt from 'markdown-it';
+import ignoreListHeading from './md-plugins/ignore-list-heading-md-plugin';
+import linkify from './md-plugins/linkify-md-plugin';
+import newline from './md-plugins/newline-md-plugin';
+import paragraph from './md-plugins/paragraph-md-plugin';
+export const md = MarkdownIt('zero', {
+  html: false
+});
+md.enable([
+// Process html entity - {, ¯, ", ...
+'entity',
+// Process escaped chars and hardbreaks
+'escape', 'newline']);
+md.use(paragraph);
+
+// enable modified version of linkify plugin
+// @see https://product-fabric.atlassian.net/browse/ED-3097
+md.use(linkify);
+md.use(newline);
+md.use(ignoreListHeading);