@atlaskit/editor-common 69.3.0 → 69.3.1

package/dist/types-ts4.0/messages/insert-block.d.ts

@@ -0,0 +1,167 @@
+export declare const toolbarInsertBlockMessages: {
+    action: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    actionDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    link: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    linkDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    filesAndImages: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    filesAndImagesDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    image: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    mention: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    mentionDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emoji: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    table: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    tableDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expand: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expandDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    decision: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    decisionDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    feedbackDialog: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    feedbackDialogDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    horizontalRule: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    horizontalRuleDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    date: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    dateDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    placeholderText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    placeholderTextDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    columns: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    columnsDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    status: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    statusDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    viewMore: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    insertMenu: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    help: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    helpDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.0/messages/link.d.ts

@@ -0,0 +1,7 @@
+export declare const linkMessages: {
+    openLink: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.0/messages/unsupportedContent.d.ts

@@ -0,0 +1,17 @@
+export declare const unsupportedContentMessages: {
+    unsupportedInlineContent: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    unsupportedBlockContent: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    unsupportedContentTooltip: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.0/node-width/index.d.ts

@@ -0,0 +1,7 @@
+import { EditorState } from 'prosemirror-state';
+import type { EditorContainerWidth } from '../types/editor-container-width';
+/**
+ * Calculates width of parent node of a nested node (inside layouts, extension)
+ * If current node selection is not nested will return undefined
+ */
+export declare const getParentNodeWidth: (pos: number | undefined, state: EditorState, containerWidth: EditorContainerWidth, isFullWidthModeEnabled?: boolean | undefined) => any;

package/dist/types-ts4.0/normalize-feature-flags.d.ts

@@ -0,0 +1,20 @@
+declare type BooleanFlags = Record<string, boolean>;
+declare type NormalizedFeatureFlags<ObjectFlags> = Partial<ObjectFlags & BooleanFlags>;
+/**
+ * Normalise and filter a free Record<string, unknown> to match
+ * the rules for feature flags in editor and renderer
+ *
+ * Input has to match to not be filtered output:
+ * 1. cased in kebab-case (match [a-z-])
+ * 2. has any value
+ *
+ * Output matches
+ * 1. cased in camelCase (match [a-zA-Z])
+ * 2. has boolean value or object {} value
+ *
+ * @param rawFeatureFlags
+ */
+export declare function normalizeFeatureFlags<ObjectFlags>(rawFeatureFlags?: Record<string, unknown>, options?: {
+    objectFlagKeys: string[];
+}): NormalizedFeatureFlags<ObjectFlags>;
+export {};

package/dist/types-ts4.0/panel.d.ts

@@ -0,0 +1 @@
+export { getPanelTypeBackground, darkPanelColors, getPanelDarkColor, panelSharedStyles, panelSharedStylesWithoutPrefix, PanelSharedCssClassName, PanelSharedSelectors, getPanelBackgroundDarkModeColors, } from './styles/shared/panel';

package/dist/types-ts4.0/provider-factory/autoformatting-provider.d.ts

@@ -0,0 +1,9 @@
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+export declare type AutoformatReplacement = ADFEntity;
+export declare type AutoformatHandler = (match: Array<string>) => Promise<AutoformatReplacement>;
+export declare type AutoformatRuleset = {
+    [regex: string]: AutoformatHandler;
+};
+export interface AutoformattingProvider {
+    getRules(): Promise<AutoformatRuleset>;
+}

package/dist/types-ts4.0/provider-factory/card-provider.d.ts

@@ -0,0 +1,7 @@
+import { CardAdf } from '@atlaskit/smart-card';
+export declare type CardAppearance = 'inline' | 'block' | 'embed';
+export type { CardAdf };
+export interface CardProvider {
+    resolve(url: string, appearance: CardAppearance, shouldForceAppearance?: boolean): Promise<CardAdf>;
+    findPattern(url: string): Promise<boolean>;
+}

package/dist/types-ts4.0/provider-factory/context-identifier-provider.d.ts

@@ -0,0 +1,6 @@
+export interface ContextIdentifierProvider {
+    containerId: string;
+    objectId: string;
+    childObjectId?: string;
+    product?: string;
+}

package/dist/types-ts4.0/provider-factory/context.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import ProviderFactory from './provider-factory';
+import { ProviderType } from './types';
+export declare const ProviderFactoryProvider: React.Provider<ProviderFactory>;
+export declare const useProviderFactory: () => ProviderFactory;
+export declare const useProvider: <T extends string>(name: T) => ProviderType<T> | undefined;

package/dist/types-ts4.0/provider-factory/image-upload-provider.d.ts

@@ -0,0 +1,6 @@
+export declare type InsertedImageProperties = {
+    src?: string;
+    alt?: string;
+    title?: string;
+};
+export declare type ImageUploadProvider = (e: Event | undefined, insertImageFn: (props: InsertedImageProperties) => void) => void;

package/dist/types-ts4.0/provider-factory/macro-provider.d.ts

@@ -0,0 +1,25 @@
+import { Node as PmNode } from 'prosemirror-model';
+import { ExtensionLayout } from '@atlaskit/adf-schema';
+export declare type ExtensionType = 'extension' | 'bodiedExtension' | 'inlineExtension';
+export interface MacroAttributes {
+    type: ExtensionType;
+    attrs: {
+        extensionKey: string;
+        extensionType: string;
+        parameters?: {
+            macroParams?: object;
+            macroMetadata?: object;
+        };
+        layout?: ExtensionLayout;
+        text?: string;
+    };
+    content?: any;
+}
+export interface MacroProvider {
+    config: {};
+    /**
+     * If "macro" param is passed in, it will open macro browser for editing the macro
+     */
+    openMacroBrowser(macroNode?: PmNode): Promise<MacroAttributes>;
+    autoConvert(link: String): MacroAttributes | null;
+}

package/dist/types-ts4.0/provider-factory/media-provider.d.ts

@@ -0,0 +1,15 @@
+import type { MediaClientConfig } from '@atlaskit/media-core/auth';
+import type { UploadParams } from '@atlaskit/media-picker/types';
+export declare type MediaProvider = {
+    uploadParams?: UploadParams;
+    /**
+     * (optional) Used for creating new uploads and finalizing files.
+     * NOTE: We currently don't accept MediaClientConfig, because we need config properties
+     *       to initialize
+     */
+    uploadMediaClientConfig?: MediaClientConfig;
+    /**
+     * Used for displaying Media Cards and downloading files.
+     */
+    viewMediaClientConfig: MediaClientConfig;
+};

package/dist/types-ts4.0/provider-factory/profile-card-provider.d.ts

@@ -0,0 +1,6 @@
+import { ProfileCardAction, ProfileClient } from '@atlaskit/profilecard';
+export interface ProfilecardProvider {
+    cloudId: string;
+    resourceClient: ProfileClient;
+    getActions: (id: string, text: string, accessLevel?: string) => ProfileCardAction[];
+}

package/dist/types-ts4.0/provider-factory/provider-factory.d.ts

@@ -0,0 +1,17 @@
+import { ProviderHandler, ProviderName, Providers, ProviderType } from './types';
+export default class ProviderFactory {
+    private providers;
+    private subscribers;
+    static create(providers: Providers & {
+        [key: string]: Promise<any> | undefined;
+    }): ProviderFactory;
+    destroy(): void;
+    isEmpty(): boolean;
+    setProvider<T extends string>(name: T, provider?: ProviderType<T>): void;
+    removeProvider<T extends string>(name: T | ProviderName): void;
+    subscribe<T extends string>(name: T, handler: ProviderHandler<typeof name>): void;
+    unsubscribe<T extends string>(name: T, handler: ProviderHandler<typeof name>): void;
+    unsubscribeAll<T extends string>(name: T | ProviderName): void;
+    hasProvider<T extends string>(name: T | ProviderName): boolean;
+    notifyUpdated<T extends string>(name: T, provider?: ProviderType<typeof name>): void;
+}

package/dist/types-ts4.0/provider-factory/quick-insert-provider.d.ts

@@ -0,0 +1,24 @@
+import { Node } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { TypeAheadItem } from '../types/type-ahead';
+export declare type QuickInsertActionInsert = (node?: Node | Record<string, any> | string, opts?: {
+    selectInlineNode?: boolean;
+}) => Transaction;
+export declare type QuickInsertItemId = 'hyperlink' | 'table' | 'helpdialog' | 'date' | 'media' | 'blockquote' | 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'codeblock' | 'unorderedList' | 'feedbackdialog' | 'orderedList' | 'rule' | 'status' | 'mention' | 'emoji' | 'action' | 'decision' | 'infopanel' | 'notepanel' | 'successpanel' | 'warningpanel' | 'errorpanel' | 'custompanel' | 'layout' | 'expand' | 'placeholderText';
+export declare type QuickInsertItem = TypeAheadItem & {
+    /** other names used to find the item */
+    keywords?: Array<string>;
+    /** categories where to find the item */
+    categories?: Array<string>;
+    /** optional sorting priority */
+    priority?: number;
+    /** optional identifier */
+    id?: QuickInsertItemId;
+    /** indicates if the item will be highlighted where approppriated (plus menu for now) */
+    featured?: boolean;
+    /** what to do on insert */
+    action: (insert: QuickInsertActionInsert, state: EditorState) => Transaction | false;
+};
+export declare type QuickInsertProvider = {
+    getItems: () => Promise<Array<QuickInsertItem>>;
+};

package/dist/types-ts4.0/provider-factory/search-provider.d.ts

@@ -0,0 +1,12 @@
+export interface QuickSearchResult {
+    objectId: string;
+    title: string;
+    url: string;
+    container: string;
+    contentType: LinkContentType;
+    updatedTimestamp?: string;
+}
+export declare type LinkContentType = 'jira.issue' | 'jira.issue.bug' | 'jira.issue.story' | 'jira.issue.task' | 'confluence.page' | 'confluence.blogpost' | 'default';
+export interface SearchProvider {
+    quickSearch(query: string, limit: number): Promise<QuickSearchResult[]>;
+}

package/dist/types-ts4.0/provider-factory/types.d.ts

@@ -0,0 +1,37 @@
+import { ActivityProvider } from '@atlaskit/activity-provider';
+import type { EmojiProvider } from '@atlaskit/emoji/types';
+import { MentionProvider } from '@atlaskit/mention/types';
+import { TaskDecisionProvider } from '@atlaskit/task-decision/types';
+import { CollabEditProvider } from '../collab/types';
+import { ExtensionProvider } from '../extensions/types';
+import { AutoformattingProvider } from './autoformatting-provider';
+import { CardProvider } from './card-provider';
+import { ContextIdentifierProvider } from './context-identifier-provider';
+import { ImageUploadProvider } from './image-upload-provider';
+import { MacroProvider } from './macro-provider';
+import { MediaProvider } from './media-provider';
+import { ProfilecardProvider } from './profile-card-provider';
+import { QuickInsertProvider } from './quick-insert-provider';
+import { SearchProvider } from './search-provider';
+export interface Providers {
+    mediaProvider?: Promise<MediaProvider>;
+    emojiProvider?: Promise<EmojiProvider>;
+    mentionProvider?: Promise<MentionProvider>;
+    extensionProvider?: Promise<ExtensionProvider>;
+    autoformattingProvider?: Promise<AutoformattingProvider>;
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    imageUploadProvider?: Promise<ImageUploadProvider>;
+    collabEditProvider?: Promise<CollabEditProvider>;
+    macroProvider?: Promise<MacroProvider>;
+    cardProvider?: Promise<CardProvider>;
+    quickInsertProvider?: Promise<QuickInsertProvider>;
+    profilecardProvider?: Promise<ProfilecardProvider>;
+    searchProvider?: Promise<SearchProvider>;
+    activityProvider?: Promise<ActivityProvider>;
+    presenceProvider?: Promise<any>;
+    reactionsStore?: Promise<any>;
+}
+export declare type ProviderName = keyof Providers;
+export declare type ProviderType<T> = T extends keyof Providers ? Providers[T] : Promise<any>;
+export declare type ProviderHandler<T extends string = any> = (name: T, provider?: ProviderType<typeof name>) => void;

package/dist/types-ts4.0/provider-factory/with-providers.d.ts

@@ -0,0 +1,18 @@
+import { PureComponent, ReactNode } from 'react';
+import ProviderFactory from './provider-factory';
+import { ProviderName, Providers } from './types';
+export interface Props {
+    providerFactory: ProviderFactory;
+    providers: ProviderName[];
+    renderNode: (providers: Providers) => ReactNode;
+}
+export declare class WithProviders extends PureComponent<Props, {
+    providers: any;
+}> {
+    static displayName: string;
+    constructor(props: Props);
+    UNSAFE_componentWillMount(): void;
+    componentWillUnmount(): void;
+    handleProvider: (name: string, provider?: Promise<any> | undefined) => void;
+    render(): ReactNode;
+}

package/dist/types-ts4.0/provider-factory.d.ts

@@ -0,0 +1,13 @@
+export { WithProviders } from './provider-factory/with-providers';
+export type { Providers, ProviderName, ProviderHandler, } from './provider-factory/types';
+export { ProviderFactoryProvider, useProviderFactory, useProvider, } from './provider-factory/context';
+export { default as ProviderFactory } from './provider-factory/provider-factory';
+export type { MediaProvider } from './provider-factory/media-provider';
+export type { ImageUploadProvider, InsertedImageProperties, } from './provider-factory/image-upload-provider';
+export type { MacroProvider, MacroAttributes, ExtensionType, } from './provider-factory/macro-provider';
+export type { SearchProvider, LinkContentType, QuickSearchResult, } from './provider-factory/search-provider';
+export type { CardProvider, CardAppearance, CardAdf, } from './provider-factory/card-provider';
+export type { QuickInsertItem, QuickInsertItemId, QuickInsertActionInsert, QuickInsertProvider, } from './provider-factory/quick-insert-provider';
+export type { TypeAheadItem, TypeAheadItemRenderProps, } from './types/type-ahead';
+export type { AutoformatReplacement, AutoformattingProvider, AutoformatHandler, AutoformatRuleset, } from './provider-factory/autoformatting-provider';
+export type { ContextIdentifierProvider } from './provider-factory/context-identifier-provider';

package/dist/types-ts4.0/provider-helpers/combine-providers.d.ts

@@ -0,0 +1,9 @@
+declare const _default: <P>(providers: (P | Promise<P>)[]) => {
+    invokeSingle: <T>(methodName: keyof P, args?: any[] | undefined) => Promise<T>;
+    invokeList: <T_1>(methodName: keyof P, args?: any[] | undefined) => Promise<T_1[]>;
+};
+/**
+ * Allow to run methods from the given provider interface across all providers seamlessly.
+ * Handles promise racing and discards rejected promises safely.
+ */
+export default _default;

package/dist/types-ts4.0/provider-helpers/index.d.ts

@@ -0,0 +1 @@
+export { default as combineProviders } from './combine-providers';

package/dist/types-ts4.0/provider-helpers/promise-helpers.d.ts

@@ -0,0 +1,32 @@
+export declare enum ResultStatus {
+    FULFILLED = "fulfilled",
+    FAILED = "failed"
+}
+declare type FulfiledResult<T> = {
+    status: ResultStatus.FULFILLED;
+    value: T;
+};
+declare type RejectedResult = {
+    status: ResultStatus.FAILED;
+    reason: any;
+};
+/**
+ * Will wait for all promises to resolve or reject, wrapping their real results in
+ * object containing the status so it's easy to filter it later. Loosely inspired by
+ * [Promise.allSettled](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled)
+ * which can replace this implementation once it makes to the browsers.
+ * @param promises
+ */
+export declare const waitForAllPromises: <T>(promises: Promise<T>[]) => Promise<(RejectedResult | FulfiledResult<T>)[]>;
+/**
+ * Will resolve on the first fulfilled promise and disregard the remaining ones. Similar to `Promise.race` but won't
+ * care about rejected promises.
+ * @param promises
+ */
+export declare const waitForFirstFulfilledPromise: <T>(promises: Promise<T>[]) => Promise<T>;
+/**
+ * Find all fullfilled promises and return their values
+ * @param results
+ */
+export declare const getOnlyFulfilled: <T>(results: (RejectedResult | FulfiledResult<T>)[]) => T[];
+export {};

package/dist/types-ts4.0/react-node-view/index.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import { Decoration, EditorView, NodeView } from 'prosemirror-view';
+import { EventDispatcher } from '../event-dispatcher';
+import type { PortalProviderAPI } from '../ui/PortalProvider';
+import { ForwardRef, getPosHandler, ReactComponentProps, shouldUpdate } from './types';
+export default class ReactNodeView<P = ReactComponentProps> implements NodeView {
+    private domRef?;
+    private contentDOMWrapper?;
+    private reactComponent?;
+    private portalProviderAPI;
+    private hasAnalyticsContext;
+    private _viewShouldUpdate?;
+    protected eventDispatcher?: EventDispatcher;
+    private hasIntlContext;
+    reactComponentProps: P;
+    view: EditorView;
+    getPos: getPosHandler;
+    contentDOM: Node | undefined;
+    node: PMNode;
+    constructor(node: PMNode, view: EditorView, getPos: getPosHandler, portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, reactComponentProps?: P, reactComponent?: React.ComponentType<any>, hasAnalyticsContext?: boolean, viewShouldUpdate?: shouldUpdate, hasIntlContext?: boolean);
+    /**
+     * This method exists to move initialization logic out of the constructor,
+     * so object can be initialized properly before calling render first time.
+     *
+     * Example:
+     * Instance properties get added to an object only after super call in
+     * constructor, which leads to some methods being undefined during the
+     * first render.
+     */
+    init(): this;
+    private renderReactComponent;
+    createDomRef(): HTMLElement;
+    getContentDOM(): {
+        dom: Node;
+        contentDOM?: Node | null | undefined;
+    } | undefined;
+    handleRef: (node: HTMLElement | null) => void;
+    private _handleRef;
+    render(props: P, forwardRef?: ForwardRef): React.ReactElement<any> | null;
+    update(node: PMNode, _decorations: Array<Decoration>, _innerDecorations?: Array<Decoration>, validUpdate?: (currentNode: PMNode, newNode: PMNode) => boolean): boolean;
+    viewShouldUpdate(nextNode: PMNode): boolean;
+    /**
+     * Copies the attributes from a ProseMirror Node to a DOM node.
+     * @param node The Prosemirror Node from which to source the attributes
+     */
+    setDomAttrs(node: PMNode, element: HTMLElement): void;
+    get dom(): HTMLElement | undefined;
+    destroy(): void;
+    private dispatchAnalyticsEvent;
+    static fromComponent(component: React.ComponentType<any>, portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, props?: ReactComponentProps, viewShouldUpdate?: (nextNode: PMNode) => boolean, hasIntlContext?: boolean): (node: PMNode, view: EditorView, getPos: getPosHandler) => ReactNodeView<ReactComponentProps>;
+}

package/dist/types-ts4.0/react-node-view/types.d.ts

@@ -0,0 +1,12 @@
+import type { Node as PMNode } from 'prosemirror-model';
+export interface ReactNodeProps {
+    selected: boolean;
+}
+export declare type ProsemirrorGetPosHandler = () => number;
+export declare type getPosHandler = getPosHandlerNode | boolean;
+export declare type getPosHandlerNode = () => number;
+export declare type ReactComponentProps = {
+    [key: string]: unknown;
+};
+export declare type ForwardRef = (node: HTMLElement | null) => void;
+export declare type shouldUpdate = (nextNode: PMNode) => boolean;

package/dist/types-ts4.0/safe-plugin/index.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'prosemirror-model';
+import { Plugin, SafePluginSpec } from 'prosemirror-state';
+export declare class SafePlugin<T = any, S extends Schema = any> extends Plugin {
+    _isATypeSafePlugin: never;
+    constructor(spec: SafePluginSpec<T, S>);
+}

package/dist/types-ts4.0/selection/gap-cursor/selection.d.ts

@@ -0,0 +1,40 @@
+import { Node as PMNode, ResolvedPos, Slice } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+export declare enum Side {
+    LEFT = "left",
+    RIGHT = "right"
+}
+export declare const JSON_ID = "gapcursor";
+export declare class GapCursorSelection extends Selection {
+    readonly side: Side;
+    readonly visible: boolean;
+    /**
+     * Construct a GapCursorSelection
+     * @param {ResolvedPos} $pos resolved position
+     * @param {Side} side side where the gap cursor is drawn
+     */
+    constructor($pos: ResolvedPos, side?: Side);
+    static valid($pos: ResolvedPos): boolean;
+    static findFrom($pos: ResolvedPos, dir: number, mustMove?: boolean): GapCursorSelection | null;
+    static fromJSON(doc: PMNode, json: {
+        pos: number;
+        type: string;
+        side: Side;
+    }): GapCursorSelection;
+    map(doc: PMNode, mapping: Mapping): Selection;
+    eq(other: Selection): boolean;
+    content(): Slice<any>;
+    getBookmark(): GapBookmark;
+    toJSON(): {
+        pos: number;
+        type: string;
+        side: Side;
+    };
+}
+export declare class GapBookmark {
+    private readonly pos;
+    constructor(pos: number);
+    map(mapping: any): GapBookmark;
+    resolve(doc: PMNode): GapCursorSelection | Selection;
+}

package/dist/types-ts4.0/selection/gap-cursor/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { isIgnored } from './is-ignored';
+export { isValidTargetNode } from './is-valid-target-node';

package/dist/types-ts4.0/selection/gap-cursor/utils/is-ignored.d.ts

@@ -0,0 +1,2 @@
+import { Node as PMNode } from 'prosemirror-model';
+export declare const isIgnored: (node?: PMNode<any> | null | undefined) => boolean;

package/dist/types-ts4.0/selection/gap-cursor/utils/is-valid-target-node.d.ts

@@ -0,0 +1,2 @@
+import { Node as PMNode } from 'prosemirror-model';
+export declare const isValidTargetNode: (node?: PMNode<any> | null | undefined) => boolean;

package/dist/types-ts4.0/selection/index.d.ts

@@ -0,0 +1,5 @@
+export { RelativeSelectionPos } from './types';
+export type { SelectionPluginState, EditorSelectionAPI } from './types';
+export { GapCursorSelection, Side, JSON_ID, GapBookmark, } from './gap-cursor/selection';
+export { isIgnored, isValidTargetNode } from './gap-cursor/utils';
+export { isSelectionAtStartOfNode, isSelectionAtEndOfNode } from './utils';