@atlaskit/editor-plugin-paste 0.1.22 → 0.2.1

package/dist/types/util/tinyMCE.d.ts

@@ -0,0 +1,32 @@
+export declare const isPastedFromTinyMCEConfluence: (pasteEvent: ClipboardEvent, html: string) => boolean;
+/**
+ * Wraps html markup with a `<table>` and uses `DOMParser` to generate
+ * and return both the table-wrapped and non-table-wrapped DOM document
+ * instances.
+ */
+export declare const wrapWithTable: (html: string) => {
+    tableWrappedDoc: Document;
+    nonTableWrappedDoc: Document;
+};
+/**
+ * Given a DOM document, it will try to rebuild table rows by using the
+ * table headers count as an initial starting point for the assumed
+ * number of columns that make up a row (`colsInRow`). It will slowly
+ * decrease that `colsInRow` count until it finds exact fit for table
+ * headers and cells with `colsInRow` else it returns the original
+ * document's markup.
+ *
+ * NOTE: It will NOT try to rebuild table rows if it encounters merged cells
+ * or compex table configurations (where table headers exist after normal
+ * table cells). It will build a single column table if NO table
+ * headers exist.
+ */
+export declare const tryReconstructTableRows: (doc: Document) => string;
+export declare const htmlHasIncompleteTable: (html: string) => boolean;
+/**
+ * Strictly for ED-7331. Given incomplete table html from tinyMCE, it will try to rebuild
+ * a whole valid table. If it rebuilds the table, it may first rebuild it as a single
+ * row table, so this also then tries to reconstruct the table rows/columns if
+ * possible (best effort).
+ */
+export declare const tryRebuildCompleteTableHtml: (incompleteTableHtml: string) => string | null;

package/dist/types-ts4.5/actions.d.ts

@@ -0,0 +1,21 @@
+import type { LastContentPasted } from './types';
+export declare enum PastePluginActionTypes {
+    START_TRACKING_PASTED_MACRO_POSITIONS = "START_TRACKING_PASTED_MACRO_POSITIONS",
+    STOP_TRACKING_PASTED_MACRO_POSITIONS = "STOP_TRACKING_PASTED_MACRO_POSITIONS",
+    ON_PASTE = "ON_PASTE"
+}
+export interface StartTrackingPastedMacroPositions {
+    type: PastePluginActionTypes.START_TRACKING_PASTED_MACRO_POSITIONS;
+    pastedMacroPositions: {
+        [key: string]: number;
+    };
+}
+export interface OnPaste {
+    type: PastePluginActionTypes.ON_PASTE;
+    contentPasted: LastContentPasted;
+}
+export interface StopTrackingPastedMacroPositions {
+    type: PastePluginActionTypes.STOP_TRACKING_PASTED_MACRO_POSITIONS;
+    pastedMacroPositionKeys: string[];
+}
+export type PastePluginAction = StartTrackingPastedMacroPositions | StopTrackingPastedMacroPositions | OnPaste;

package/dist/types-ts4.5/commands.d.ts

@@ -0,0 +1,29 @@
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Mark, Schema } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Use this to register macro link positions during a paste operation, that you
+ * want to track in a document over time, through any document changes.
+ *
+ * @param positions a map of string keys (custom position references) and position values e.g. { ['my-key-1']: 11 }
+ *
+ * **Context**: This is neccessary if there is an async process or an unknown period of time
+ * between obtaining an original position, and wanting to know about what its final eventual
+ * value. In that scenario, positions will need to be actively tracked and mapped in plugin
+ * state so that they can be mapped through any other independent document change transactions being
+ * dispatched to the editor that could affect their value.
+ */
+export declare const startTrackingPastedMacroPositions: (pastedMacroPositions: {
+    [key: string]: number;
+}) => import("@atlaskit/editor-common/types").Command;
+export declare const stopTrackingPastedMacroPositions: (pastedMacroPositionKeys: string[]) => import("@atlaskit/editor-common/types").Command;
+export declare const upgradeTextToLists: (slice: Slice, schema: Schema) => Slice;
+export declare const splitParagraphs: (slice: Slice, schema: Schema) => Slice;
+/**
+ * Walks the slice, creating paragraphs that were previously separated by hardbreaks.
+ * Returns the original paragraph node (as a fragment), or a fragment containing multiple nodes.
+ */
+export declare const splitIntoParagraphs: ({ fragment, blockMarks, schema, }: {
+    fragment: Fragment;
+    blockMarks?: readonly Mark[] | undefined;
+    schema: Schema;
+}) => Fragment;

package/dist/types-ts4.5/edge-cases/index.d.ts

@@ -0,0 +1,11 @@
+import type { Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function insertSliceForLists({ tr, slice, schema, }: {
+    tr: Transaction;
+    slice: Slice;
+    schema: Schema;
+}): void | Transaction;
+export declare function insertSliceForListsInsideBlockquote({ tr, slice, }: {
+    tr: Transaction;
+    slice: Slice;
+}): Transaction | undefined;

package/dist/types-ts4.5/edge-cases/lists.d.ts

@@ -0,0 +1,18 @@
+import type { Node as PMNode, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function insertSliceIntoEmptyNode({ tr, slice, }: {
+    tr: Transaction;
+    slice: Slice;
+}): void;
+export declare function insertSliceAtNodeEdge({ tr, slice, }: {
+    tr: Transaction;
+    slice: Slice;
+}): void;
+export declare function insertSliceIntoRangeSelectionInsideList({ tr, slice, }: {
+    tr: Transaction;
+    slice: Slice;
+}): Transaction | undefined;
+export declare function insertSliceInsideOfPanelNodeSelected(panelNode: PMNode): ({ tr, slice }: {
+    tr: Transaction;
+    slice: Slice;
+}) => void;

package/dist/types-ts4.5/handlers.d.ts

@@ -0,0 +1,55 @@
+import type { EditorAnalyticsAPI, InputMethodInsertMedia } from '@atlaskit/editor-common/analytics';
+import type { CardOptions, QueueCardsFromTransactionAction } from '@atlaskit/editor-common/card';
+import type { ExtensionAutoConvertHandler } from '@atlaskit/editor-common/extensions';
+import type { Command } from '@atlaskit/editor-common/types';
+import type { RunMacroAutoConvert } from '@atlaskit/editor-plugin-extension';
+import type { FindRootParentListNode } from '@atlaskit/editor-plugin-list';
+import type { InsertMediaAsMediaSingle } from '@atlaskit/editor-plugin-media/types';
+import { Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Selection } from '@atlaskit/editor-prosemirror/state';
+export declare function handleMention(slice: Slice, schema: Schema): Slice;
+export declare function handlePasteIntoTaskOrDecisionOrPanel(slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined): Command;
+export declare function handlePasteNonNestableBlockNodesIntoList(slice: Slice): Command;
+export declare const doesSelectionWhichStartsOrEndsInListContainEntireList: (selection: Selection, findRootParentListNode: FindRootParentListNode | undefined) => boolean;
+export declare function handlePastePanelOrDecisionContentIntoList(slice: Slice, findRootParentListNode: FindRootParentListNode | undefined): Command;
+export declare function handlePasteLinkOnSelectedText(slice: Slice): Command;
+export declare function handlePasteAsPlainText(slice: Slice, _event: ClipboardEvent, editorAnalyticsAPI: EditorAnalyticsAPI | undefined): Command;
+export declare function handlePastePreservingMarks(slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined): Command;
+export declare function handleMacroAutoConvert(text: string, slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined, runMacroAutoConvert: RunMacroAutoConvert | undefined, cardsOptions?: CardOptions, extensionAutoConverter?: ExtensionAutoConvertHandler): Command;
+export declare function handleCodeBlock(text: string): Command;
+export declare function handleMediaSingle(inputMethod: InputMethodInsertMedia, insertMediaAsMediaSingle: InsertMediaAsMediaSingle | undefined): (slice: Slice) => Command;
+export declare function handleExpandPasteInTable(slice: Slice): Command;
+export declare function handleMarkdown(markdownSlice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined, from?: number, to?: number): Command;
+export declare function handleParagraphBlockMarks(state: EditorState, slice: Slice): Slice;
+/**
+ * ED-6300: When a nested list is pasted in a table cell and the slice has openStart > openEnd,
+ * it splits the table. As a workaround, we flatten the list to even openStart and openEnd.
+ *
+ * Note: this only happens if the first child is a list
+ *
+ * Example: copying "one" and "two"
+ * - zero
+ *   - one
+ * - two
+ *
+ * Before:
+ * ul
+ *   ┗━ li
+ *     ┗━ ul
+ *       ┗━ li
+ *         ┗━ p -> "one"
+ *   ┗━ li
+ *     ┗━ p -> "two"
+ *
+ * After:
+ * ul
+ *   ┗━ li
+ *     ┗━ p -> "one"
+ *   ┗━ li
+ *     ┗━p -> "two"
+ */
+export declare function flattenNestedListInSlice(slice: Slice): Slice;
+export declare function handleRichText(slice: Slice, queueCardsFromChangedTr: QueueCardsFromTransactionAction | undefined): Command;
+export declare function handlePasteIntoCaption(slice: Slice): Command;
+export declare const handleSelectedTable: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (slice: Slice) => Command;

package/dist/types-ts4.5/index.d.ts

@@ -1 +1,2 @@
 export type { PastePlugin, PastePluginOptions, PastePluginState, LastContentPasted, } from './types';
+export { pastePlugin } from './plugin';

package/dist/types-ts4.5/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { PastePlugin } from './types';
+export declare const pastePlugin: PastePlugin;

package/dist/types-ts4.5/plugins/media.d.ts

@@ -0,0 +1,23 @@
+import type { Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { Selection } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Ensure correct layout in nested mode
+ *
+ * TODO: this func is only used in handlePaste, so layout update won't work for drop event
+ */
+export declare function transformSliceForMedia(slice: Slice, schema: Schema): (selection: Selection) => Slice;
+export declare const isImage: (fileType?: string) => boolean;
+export declare const transformSliceToCorrectMediaWrapper: (slice: Slice, schema: Schema) => Slice;
+/**
+ * This func will be called when copy & paste, drag & drop external html with media, media files, and slices from editor
+ * Because width may not be available when transform, DEFAULT_IMAGE_WIDTH is used as a fallback
+ *
+ */
+export declare const transformSliceToMediaSingleWithNewExperience: (slice: Slice, schema: Schema) => Slice;
+/**
+ * Given a html string, we attempt to hoist any nested `<img>` tags,
+ * not directly wrapped by a `<div>` as ProseMirror no-op's
+ * on those scenarios.
+ * @param html
+ */
+export declare const unwrapNestedMediaElements: (html: string) => string;

package/dist/types-ts4.5/pm-plugins/analytics.d.ts

@@ -0,0 +1,44 @@
+import type { AnalyticsEventPayload, EditorAnalyticsAPI, PasteContent, PasteType } from '@atlaskit/editor-common/analytics';
+import type { Command, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { FindRootParentListNode } from '@atlaskit/editor-plugin-list';
+import type { InsertMediaAsMediaSingle } from '@atlaskit/editor-plugin-media/types';
+import type { Fragment, Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { PastePlugin } from '../index';
+type PasteContext = {
+    type: PasteType;
+    asPlain?: boolean;
+    /** Has the hyperlink been pasted while text is selected, making the text into a link? */
+    hyperlinkPasteOnText?: boolean;
+    /** Did this paste action split a list in half? */
+    pasteSplitList?: boolean;
+};
+type GetContentProps = {
+    schema: Schema;
+    slice: Slice;
+};
+export declare function getContent({ schema, slice }: GetContentProps): PasteContent;
+export declare function getMediaTraceId(slice: Slice): undefined;
+export declare function createPasteAnalyticsPayload(view: EditorView, event: ClipboardEvent, slice: Slice, pasteContext: PasteContext): AnalyticsEventPayload;
+export declare const sendPasteAnalyticsEvent: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, pasteContext: PasteContext) => void;
+export declare const handlePasteAsPlainTextWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice) => Command;
+export declare const handlePasteIntoTaskAndDecisionWithAnalytics: (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined) => Command;
+export declare const handlePasteIntoCaptionWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType) => Command;
+export declare const handleCodeBlockWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, text: string) => Command;
+export declare const handleMediaSingleWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType, insertMediaAsMediaSingle: InsertMediaAsMediaSingle | undefined) => Command;
+export declare const handlePastePreservingMarksWithAnalytics: (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined) => Command;
+export declare const handleMarkdownWithAnalytics: (view: EditorView, event: ClipboardEvent, slice: Slice, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined) => Command;
+export declare const handleRichTextWithAnalytics: (view: EditorView, event: ClipboardEvent, slice: Slice, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined) => Command;
+export declare const handlePastePanelOrDecisionIntoListWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, findRootParentListNode: FindRootParentListNode | undefined) => Command;
+export declare const handlePasteNonNestableBlockNodesIntoListWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice) => Command;
+export declare const handleExpandWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice) => Command;
+export declare const handleSelectedTableWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice) => Command;
+export declare const handlePasteLinkOnSelectedTextWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, event: ClipboardEvent, slice: Slice, type: PasteType) => Command;
+export declare const createPasteMeasurePayload: ({ view, duration, content, distortedDuration, }: {
+    view: EditorView;
+    duration: number;
+    content: Array<string>;
+    distortedDuration: boolean;
+}) => AnalyticsEventPayload;
+export declare const getContentNodeTypes: (content: Fragment) => string[];
+export {};

package/dist/types-ts4.5/pm-plugins/clipboard-text-serializer.d.ts

@@ -0,0 +1,13 @@
+import type { Slice } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Returns a plain text serialization of a given slice. This is used for populating the plain text
+ * section of the clipboard on copy.
+ * The current implementation is bare bones - only inlineCards, blockCards and mentions are tested (they
+ * previously were empty on plain text copy).
+ * Unknown nodes are passed to node.textBetween().
+ *
+ * By default (without this function passed to the editor), the editor uses
+ * `slice.content.textBetween(0, slice.content.size, "\n\n")`
+ * (see https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextSerializer)
+ */
+export declare function clipboardTextSerializer(slice: Slice): string;

package/dist/types-ts4.5/pm-plugins/main.d.ts

@@ -0,0 +1,12 @@
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { CardOptions } from '@atlaskit/editor-common/card';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI, FeatureFlags } from '@atlaskit/editor-common/types';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { PastePlugin } from '../index';
+export { pluginKey as stateKey } from './plugin-factory';
+export declare const isInsideBlockQuote: (state: EditorState) => boolean;
+export declare function createPlugin(schema: Schema, dispatchAnalyticsEvent: DispatchAnalyticsEvent, dispatch: Dispatch, featureFlags: FeatureFlags, pluginInjectionApi: ExtractInjectionAPI<PastePlugin> | undefined, cardOptions?: CardOptions, sanitizePrivateContent?: boolean, providerFactory?: ProviderFactory): SafePlugin<import("../types").PastePluginState>;

package/dist/types-ts4.5/pm-plugins/plugin-factory.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const pluginKey: PluginKey<any>;
+export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: import("..").PastePluginState | ((state: import("prosemirror-state").EditorState) => import("..").PastePluginState)) => import("prosemirror-state").SafeStateField<import("..").PastePluginState>, createCommand: <A = import("../actions").PastePluginAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command, getPluginState: (state: import("prosemirror-state").EditorState) => import("..").PastePluginState;

package/dist/types-ts4.5/reducer.d.ts

@@ -0,0 +1,3 @@
+import type { PastePluginAction as Action } from './actions';
+import type { PastePluginState as State } from './types';
+export declare const reducer: (state: State, action: Action) => State;

package/dist/types-ts4.5/util/index.d.ts

@@ -0,0 +1,21 @@
+import type { EditorAnalyticsAPI, PasteSource } from '@atlaskit/editor-common/analytics';
+import type { CardOptions } from '@atlaskit/editor-common/card';
+import type { NodeType, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Mark, Slice } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Selection, Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function isPastedFromWord(html?: string): boolean;
+export declare function isPastedFromExcel(html?: string): boolean;
+export declare const isSingleLine: (text: string) => boolean;
+export declare function htmlContainsSingleFile(html: string): boolean;
+export declare function getPasteSource(event: ClipboardEvent): PasteSource;
+export declare function escapeLinks(text: string): string;
+export declare function hasOnlyNodesOfType(...nodeTypes: NodeType[]): (slice: Slice) => boolean;
+export declare function applyTextMarksToSlice(schema: Schema, marks?: readonly Mark[]): (slice: Slice) => Slice;
+export declare function isEmptyNode(node: PMNode | null | undefined): boolean | null;
+export declare function isCursorSelectionAtTextStartOrEnd(selection: Selection): boolean | null;
+export declare function isPanelNode(node: PMNode | null | undefined): boolean;
+export declare function isSelectionInsidePanel(selection: Selection): PMNode | null;
+export declare const htmlHasInvalidLinkTags: (html?: string) => boolean;
+export declare const removeDuplicateInvalidLinks: (html: string) => string;
+export declare const addReplaceSelectedTableAnalytics: (state: EditorState, tr: Transaction, editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Transaction;
+export declare const transformUnsupportedBlockCardToInline: (slice: Slice, state: EditorState, cardOptions?: CardOptions) => Slice;

package/dist/types-ts4.5/util/tinyMCE.d.ts

@@ -0,0 +1,32 @@
+export declare const isPastedFromTinyMCEConfluence: (pasteEvent: ClipboardEvent, html: string) => boolean;
+/**
+ * Wraps html markup with a `<table>` and uses `DOMParser` to generate
+ * and return both the table-wrapped and non-table-wrapped DOM document
+ * instances.
+ */
+export declare const wrapWithTable: (html: string) => {
+    tableWrappedDoc: Document;
+    nonTableWrappedDoc: Document;
+};
+/**
+ * Given a DOM document, it will try to rebuild table rows by using the
+ * table headers count as an initial starting point for the assumed
+ * number of columns that make up a row (`colsInRow`). It will slowly
+ * decrease that `colsInRow` count until it finds exact fit for table
+ * headers and cells with `colsInRow` else it returns the original
+ * document's markup.
+ *
+ * NOTE: It will NOT try to rebuild table rows if it encounters merged cells
+ * or compex table configurations (where table headers exist after normal
+ * table cells). It will build a single column table if NO table
+ * headers exist.
+ */
+export declare const tryReconstructTableRows: (doc: Document) => string;
+export declare const htmlHasIncompleteTable: (html: string) => boolean;
+/**
+ * Strictly for ED-7331. Given incomplete table html from tinyMCE, it will try to rebuild
+ * a whole valid table. If it rebuilds the table, it may first rebuild it as a single
+ * row table, so this also then tries to reconstruct the table rows/columns if
+ * possible (best effort).
+ */
+export declare const tryRebuildCompleteTableHtml: (incompleteTableHtml: string) => string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/editor-plugin-paste",
-  "version": "0.1.22",
+  "version": "0.2.1",
   "description": "Paste plugin for @atlaskit/editor-core",
   "author": "Atlassian Pty Ltd",
   "license": "Apache-2.0",
@@ -32,15 +32,23 @@
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@atlaskit/editor-common": "^76.29.0",
+    "@atlaskit/editor-common": "^76.30.0",
+    "@atlaskit/editor-markdown-transformer": "^5.2.5",
     "@atlaskit/editor-plugin-analytics": "^0.4.0",
     "@atlaskit/editor-plugin-annotation": "^0.1.0",
     "@atlaskit/editor-plugin-better-type-history": "^0.1.0",
     "@atlaskit/editor-plugin-card": "^0.14.0",
     "@atlaskit/editor-plugin-feature-flags": "^1.0.0",
     "@atlaskit/editor-plugin-list": "^3.0.0",
-    "@atlaskit/editor-plugin-media": "^0.8.0",
-    "@babel/runtime": "^7.0.0"
+    "@atlaskit/editor-plugin-media": "^0.9.0",
+    "@atlaskit/editor-prosemirror": "1.1.0",
+    "@atlaskit/editor-tables": "^2.3.0",
+    "@atlaskit/media-client": "^26.1.0",
+    "@atlaskit/media-common": "^11.0.0",
+    "@atlaskit/platform-feature-flags": "^0.2.0",
+    "@babel/runtime": "^7.0.0",
+    "lodash": "^4.17.21",
+    "uuid": "^3.1.0"
   },
   "peerDependencies": {
     "react": "^16.8.0"
@@ -50,7 +58,6 @@
     "@atlaskit/adf-schema": "^35.2.0",
     "@atlaskit/editor-plugin-history": "^0.1.0",
     "@atlaskit/editor-plugin-type-ahead": "^0.8.0",
-    "@atlaskit/editor-prosemirror": "1.1.0",
     "@atlaskit/ssr": "*",
     "@atlaskit/visual-regression": "*",
     "@atlaskit/webdriver-runner": "*",
@@ -103,5 +110,10 @@
       "@atlassian/tangerine/project-structure"
     ]
   },
-  "prettier": "@atlassian/atlassian-frontend-prettier-config-1.0.0"
+  "prettier": "@atlassian/atlassian-frontend-prettier-config-1.0.0",
+  "platform-feature-flags": {
+    "platform.editor.media.extended-resize-experience": {
+      "type": "boolean"
+    }
+  }
 }