@gravity-ui/markdown-editor 13.0.0

package/build/esm/utils/autocomplete-popup.d.ts

@@ -0,0 +1,13 @@
+import type { PopupProps } from '@gravity-ui/uikit';
+import type { EditorView } from 'prosemirror-view';
+export declare type AutocompletePopupProps = Pick<PopupProps, 'onOutsideClick' | 'onEscapeKeyDown' | 'onEnterKeyDown'> & {
+    anchor?: Element | null;
+};
+export declare class AutocompletePopupCloser {
+    #private;
+    constructor(view: EditorView);
+    popupEscapeKeyHandler: NonNullable<PopupProps['onEscapeKeyDown']>;
+    popupOutsideClickHandler: NonNullable<PopupProps['onOutsideClick']>;
+    closeAutocomplete(): void;
+    cancelTimer(): void;
+}

package/build/esm/utils/autocomplete-popup.js

@@ -0,0 +1,33 @@
+var _AutocompletePopupCloser_view, _AutocompletePopupCloser_timer;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { closeAutocomplete } from '../extensions/behavior/Autocomplete';
+export class AutocompletePopupCloser {
+    constructor(view) {
+        _AutocompletePopupCloser_view.set(this, void 0);
+        _AutocompletePopupCloser_timer.set(this, void 0);
+        this.popupEscapeKeyHandler = () => {
+            this.closeAutocomplete();
+        };
+        this.popupOutsideClickHandler = () => {
+            if (!__classPrivateFieldGet(this, _AutocompletePopupCloser_view, "f").hasFocus()) {
+                __classPrivateFieldSet(this, _AutocompletePopupCloser_timer, setTimeout(() => {
+                    __classPrivateFieldSet(this, _AutocompletePopupCloser_timer, undefined, "f");
+                    if (!__classPrivateFieldGet(this, _AutocompletePopupCloser_view, "f").hasFocus()) {
+                        this.closeAutocomplete();
+                    }
+                }, 20), "f");
+            }
+        };
+        __classPrivateFieldSet(this, _AutocompletePopupCloser_view, view, "f");
+    }
+    closeAutocomplete() {
+        closeAutocomplete(__classPrivateFieldGet(this, _AutocompletePopupCloser_view, "f"));
+    }
+    cancelTimer() {
+        if (__classPrivateFieldGet(this, _AutocompletePopupCloser_timer, "f") !== undefined) {
+            clearTimeout(__classPrivateFieldGet(this, _AutocompletePopupCloser_timer, "f"));
+            __classPrivateFieldSet(this, _AutocompletePopupCloser_timer, undefined, "f");
+        }
+    }
+}
+_AutocompletePopupCloser_view = new WeakMap(), _AutocompletePopupCloser_timer = new WeakMap();

package/build/esm/utils/carousel/ArrayCarousel.d.ts

@@ -0,0 +1,11 @@
+export declare class ArrayCarousel<T> {
+    private _array;
+    private indexCarousel;
+    constructor(array: readonly T[]);
+    get array(): readonly T[];
+    get currentIndex(): number;
+    set currentIndex(value: number);
+    get currentItem(): T | undefined;
+    next(): this;
+    prev(): this;
+}

package/build/esm/utils/carousel/ArrayCarousel.js

@@ -0,0 +1,30 @@
+import { IndexCarousel } from './IndexCarousel';
+export class ArrayCarousel {
+    constructor(array) {
+        if (!Array.isArray(array)) {
+            throw new Error('ArrayCarousel: "array" argument must be array');
+        }
+        this._array = array;
+        this.indexCarousel = new IndexCarousel(array.length);
+    }
+    get array() {
+        return this._array;
+    }
+    get currentIndex() {
+        return this.indexCarousel.current;
+    }
+    set currentIndex(value) {
+        this.indexCarousel.current = value;
+    }
+    get currentItem() {
+        return this.array[this.currentIndex];
+    }
+    next() {
+        this.indexCarousel.next();
+        return this;
+    }
+    prev() {
+        this.indexCarousel.prev();
+        return this;
+    }
+}

package/build/esm/utils/carousel/IndexCarousel.d.ts

@@ -0,0 +1,11 @@
+export declare class IndexCarousel {
+    private static isValidLength;
+    private length;
+    private _current;
+    constructor(length: number, start?: number);
+    get current(): number;
+    set current(value: number);
+    next(): number;
+    prev(): number;
+    reset(newLength?: number): void;
+}

package/build/esm/utils/carousel/IndexCarousel.js

@@ -0,0 +1,59 @@
+export class IndexCarousel {
+    constructor(length, start) {
+        this._current = 0;
+        if (!IndexCarousel.isValidLength(length)) {
+            throw new Error('IndexCarousel: length must be greater or equal zero');
+        }
+        this.length = length;
+        if (start !== undefined) {
+            if (!Number.isSafeInteger(start)) {
+                throw new Error('IndexCarousel: start must be safe integer');
+            }
+            if (start < 0)
+                throw new Error('IndexCarousel: start must be greater or equal zero');
+            if (start >= length)
+                throw new Error('IndexCarousel: start must be lower than length');
+            this.current = start;
+        }
+    }
+    static isValidLength(value) {
+        return Number.isSafeInteger(length) && value >= 0;
+    }
+    get current() {
+        if (this.length <= 0)
+            return -1;
+        return this._current;
+    }
+    set current(value) {
+        if (value < 0 || value >= this.length) {
+            throw new Error('IndexCarousel: new current must be in the range from 0 to length-1');
+        }
+        this._current = value;
+    }
+    next() {
+        if (this.length <= 0)
+            return -1;
+        let next = this.current + 1;
+        next %= this.length;
+        this.current = next;
+        return next;
+    }
+    prev() {
+        if (this.length <= 0)
+            return -1;
+        let prev = this.current - 1;
+        prev += this.length;
+        prev %= this.length;
+        this.current = prev;
+        return prev;
+    }
+    reset(newLength) {
+        if (newLength !== undefined) {
+            if (!IndexCarousel.isValidLength(newLength)) {
+                throw new Error('IndexCarousel: newLength must be greater or equal zero');
+            }
+            this.length = newLength;
+        }
+        this.current = 0;
+    }
+}

package/build/esm/utils/carousel/index.d.ts

@@ -0,0 +1,2 @@
+export { IndexCarousel } from './IndexCarousel';
+export { ArrayCarousel } from './ArrayCarousel';

package/build/esm/utils/carousel/index.js

@@ -0,0 +1,2 @@
+export { IndexCarousel } from './IndexCarousel';
+export { ArrayCarousel } from './ArrayCarousel';

package/build/esm/utils/clipboard.d.ts

@@ -0,0 +1,12 @@
+/** Сontains all data formats known to us */
+export declare enum DataTransferType {
+    Text = "text/plain",
+    Html = "text/html",
+    Yfm = "text/yfm",
+    UriList = "text/uri-list",
+    VSCodeData = "vscode-editor-data",
+    Files = "Files"
+}
+export declare function isFilesOnly({ types }: DataTransfer): boolean;
+export declare function isFilesFromHtml({ types }: DataTransfer): boolean;
+export declare function isImageFile(file: File): boolean;

package/build/esm/utils/clipboard.js

@@ -0,0 +1,21 @@
+/** Сontains all data formats known to us */
+export var DataTransferType;
+(function (DataTransferType) {
+    DataTransferType["Text"] = "text/plain";
+    DataTransferType["Html"] = "text/html";
+    DataTransferType["Yfm"] = "text/yfm";
+    DataTransferType["UriList"] = "text/uri-list";
+    DataTransferType["VSCodeData"] = "vscode-editor-data";
+    DataTransferType["Files"] = "Files";
+})(DataTransferType || (DataTransferType = {}));
+export function isFilesOnly({ types }) {
+    return types.length === 1 && types[0] === DataTransferType.Files;
+}
+export function isFilesFromHtml({ types }) {
+    return (types.length === 2 &&
+        types.includes(DataTransferType.Files) &&
+        types.includes(DataTransferType.Html));
+}
+export function isImageFile(file) {
+    return file.type.startsWith('image/');
+}

package/build/esm/utils/ecapeRegexp.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
+ * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
+ *
+ * @category String
+ * @param {string} [src=''] The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @see escape, escapeRegExp, unescape
+ * @example
+ *
+ * escapeRegExp('[lodash](https://lodash.com/)')
+ * // => '\[lodash\]\(https://lodash\.com/\)'
+ */
+export declare function escapeRegExp(src: string): string;

package/build/esm/utils/ecapeRegexp.js

@@ -0,0 +1,22 @@
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+const reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+const reHasRegExpChar = RegExp(reRegExpChar.source);
+/**
+ * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
+ * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
+ *
+ * @category String
+ * @param {string} [src=''] The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @see escape, escapeRegExp, unescape
+ * @example
+ *
+ * escapeRegExp('[lodash](https://lodash.com/)')
+ * // => '\[lodash\]\(https://lodash\.com/\)'
+ */
+export function escapeRegExp(src) {
+    return src && reHasRegExpChar.test(src) ? src.replace(reRegExpChar, '\\$&') : src || '';
+}

package/build/esm/utils/event-emitter.d.ts

@@ -0,0 +1,26 @@
+declare type UnkObj = {
+    [key: string]: unknown;
+};
+export declare type Listener<T> = (value: T) => void;
+export interface Emitter<T extends object = UnkObj> {
+    emit<K extends keyof T>(type: K, data: T[K]): void;
+}
+export interface Receiver<T extends object = UnkObj> {
+    on<K extends keyof T>(type: K, listener: Listener<T[K]>): void;
+    off<K extends keyof T>(type: K, listener: Listener<T[K]>): void;
+}
+export declare class EventEmitter<T extends object = UnkObj> implements Emitter<T>, Receiver<T> {
+    protected _listeners: Map<keyof T, Listener<any>[]>;
+    on<K extends keyof T>(type: K, listener: Listener<T[K]>): void;
+    off<K extends keyof T>(type: K, listener: Listener<T[K]>): void;
+    emit<K extends keyof T>(type: K, value: T[K]): void;
+}
+export declare class SafeEventEmitter<T extends object = UnkObj> extends EventEmitter<T> {
+    private onError;
+    constructor(options?: {
+        onError?: (error: unknown) => void;
+    });
+    emit<K extends keyof T>(type: K, value: T[K]): void;
+    private safeExec;
+}
+export {};

package/build/esm/utils/event-emitter.js

@@ -0,0 +1,39 @@
+export class EventEmitter {
+    constructor() {
+        this._listeners = new Map();
+    }
+    on(type, listener) {
+        if (!this._listeners.has(type)) {
+            this._listeners.set(type, []);
+        }
+        this._listeners.get(type).push(listener);
+    }
+    off(type, listener) {
+        if (this._listeners.has(type)) {
+            this._listeners.set(type, this._listeners.get(type).filter((val) => val !== listener));
+        }
+    }
+    emit(type, value) {
+        var _a;
+        (_a = this._listeners.get(type)) === null || _a === void 0 ? void 0 : _a.forEach((listener) => listener(value));
+    }
+}
+export class SafeEventEmitter extends EventEmitter {
+    constructor(options) {
+        var _a;
+        super();
+        this.onError = (_a = options === null || options === void 0 ? void 0 : options.onError) !== null && _a !== void 0 ? _a : console.error;
+    }
+    emit(type, value) {
+        var _a;
+        (_a = this._listeners.get(type)) === null || _a === void 0 ? void 0 : _a.forEach((listener) => this.safeExec(() => listener(value)));
+    }
+    safeExec(fn) {
+        try {
+            fn();
+        }
+        catch (e) {
+            this.onError(e);
+        }
+    }
+}

package/build/esm/utils/helpers.d.ts

@@ -0,0 +1,12 @@
+import type Token from 'markdown-it/lib/token';
+export declare const attrsFromEntries: (tok: Token) => {
+    [k: string]: string;
+};
+export declare type TryCatchReturnType<R> = {
+    success: true;
+    result: R;
+} | {
+    success: false;
+    error: any;
+};
+export declare function tryCatch<R>(fn: () => R): TryCatchReturnType<R>;

package/build/esm/utils/helpers.js

@@ -0,0 +1,15 @@
+export const attrsFromEntries = (tok) => {
+    if (tok.attrs)
+        return Object.fromEntries(tok.attrs);
+    return {};
+};
+export function tryCatch(fn) {
+    try {
+        const result = fn();
+        return { success: true, result };
+    }
+    catch (error) {
+        console.error(error);
+        return { success: false, error };
+    }
+}

package/build/esm/utils/index.d.ts

@@ -0,0 +1,20 @@
+export * from './actions';
+export * from './autocomplete-popup';
+export * from './carousel';
+export * from './clipboard';
+export * from './ecapeRegexp';
+export * from './event-emitter';
+export * from './helpers';
+export { markInputRule, nodeInputRule, inlineNodeInputRule, textblockTypeInputRule, wrappingInputRule, } from './inputrules';
+export * from './keymap';
+export * from './marks';
+export * from './node-children';
+export * from './nodes';
+export * from './placeholder';
+export * from './platform';
+export * from './remove-node';
+export * from './schema';
+export * from './selection';
+export * from './serialize-for-clipboard';
+export * from './sync-scroll';
+export * from './upload';

package/build/esm/utils/index.js

@@ -0,0 +1,20 @@
+export * from './actions';
+export * from './autocomplete-popup';
+export * from './carousel';
+export * from './clipboard';
+export * from './ecapeRegexp';
+export * from './event-emitter';
+export * from './helpers';
+export { markInputRule, nodeInputRule, inlineNodeInputRule, textblockTypeInputRule, wrappingInputRule, } from './inputrules';
+export * from './keymap';
+export * from './marks';
+export * from './node-children';
+export * from './nodes';
+export * from './placeholder';
+export * from './platform';
+export * from './remove-node';
+export * from './schema';
+export * from './selection';
+export * from './serialize-for-clipboard';
+export * from './sync-scroll';
+export * from './upload';

package/build/esm/utils/inputrules.d.ts

@@ -0,0 +1,13 @@
+import { InputRule } from 'prosemirror-inputrules';
+import { Fragment, MarkType, Node } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+export declare function hasCodeMark(state: EditorState, _match: RegExpMatchArray, start: number, end: number): boolean;
+export { textblockTypeInputRule, wrappingInputRule } from './rulebuilders';
+export declare function markInputRule(rule: RegExp | {
+    open: string;
+    close: string;
+    ignoreBetween?: string;
+}, markType: MarkType, getAttrs?: (match: any) => Record<string, unknown>): InputRule;
+declare type NodeInputRuleReplaceFragment = Node | Fragment | readonly Node[] | null | undefined;
+export declare function nodeInputRule(regexp: RegExp, fragment: NodeInputRuleReplaceFragment | ((match: string) => NodeInputRuleReplaceFragment), selectionOffset?: number): InputRule;
+export declare function inlineNodeInputRule(regexp: RegExp, fragment: (match: string) => NodeInputRuleReplaceFragment): InputRule;

package/build/esm/utils/inputrules.js

@@ -0,0 +1,117 @@
+import { InputRule } from 'prosemirror-inputrules';
+import { Fragment } from 'prosemirror-model';
+import { TextSelection } from 'prosemirror-state';
+import { codeType } from '../extensions/markdown/specs';
+import { isFunction } from '../lodash';
+import { isMarkActive } from '../utils/marks';
+// TODO: remove explicit import from code extension
+export function hasCodeMark(state, _match, start, end) {
+    // TODO: remove explicit import from code extension
+    const codeMarkType = codeType(state.schema);
+    if (isMarkActive(state, codeMarkType))
+        return true;
+    if (state.doc.rangeHasMark(start, end, codeMarkType))
+        return true;
+    return false;
+}
+export { textblockTypeInputRule, wrappingInputRule } from './rulebuilders';
+function getMarksBetween(start, end, state) {
+    let marks = [];
+    state.doc.nodesBetween(start, end, (node, pos) => {
+        marks = [
+            ...marks,
+            ...node.marks.map((mark) => ({
+                start: pos,
+                end: pos + node.nodeSize,
+                mark,
+            })),
+        ];
+    });
+    return marks;
+}
+function escapeRegex(string) {
+    // eslint-disable-next-line no-useless-escape
+    return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+// TODO: link has a custom input rule handler, think about generalizing
+export function markInputRule(rule, markType, getAttrs) {
+    let regexp;
+    if (rule instanceof RegExp) {
+        regexp = rule;
+    }
+    else {
+        const open = escapeRegex(rule.open);
+        const close = escapeRegex(rule.close);
+        const ignoreBetween = escapeRegex(rule.ignoreBetween || '');
+        regexp = new RegExp(`(?:${open})` +
+            (ignoreBetween ? `([^\\s${ignoreBetween}]+)` : `([\\S]+)`) +
+            `(?:${close})\\s$`);
+    }
+    return new InputRule(regexp, (state, match, start, end) => {
+        // handle the rule only if is start of line or there is a space before "open" symbols
+        if (match.index > 0) {
+            const re = match;
+            if (re.input[re.index - 1] !== ' ')
+                return null;
+        }
+        if (hasCodeMark(state, match, start, end))
+            return null;
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        const { tr } = state;
+        const m = match.length - 1;
+        let markEnd = end;
+        let markStart = start;
+        if (match[m]) {
+            const matchStart = start + match[0].indexOf(match[m - 1]);
+            const matchEnd = matchStart + match[m - 1].length - 1;
+            const textStart = matchStart + match[m - 1].lastIndexOf(match[m]);
+            const textEnd = textStart + match[m].length;
+            const marksBetween = getMarksBetween(start, end, state);
+            const excludedMarks = marksBetween
+                .filter((item) => item.mark.type.excludes(markType))
+                .filter((item) => item.end > matchStart);
+            if (excludedMarks.length) {
+                return null;
+            }
+            if (textEnd < matchEnd) {
+                tr.delete(textEnd, matchEnd);
+            }
+            if (textStart > matchStart) {
+                tr.delete(matchStart, textStart);
+            }
+            markStart = matchStart;
+            markEnd = markStart + match[m].length;
+        }
+        tr.addMark(markStart, markEnd, markType.create(attrs));
+        tr.removeStoredMark(markType);
+        return tr;
+    });
+}
+export function nodeInputRule(regexp, fragment, selectionOffset = 0) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        var _a;
+        if (hasCodeMark(state, match, start, end))
+            return null;
+        const [matchStr] = match;
+        const { tr } = state;
+        if (matchStr) {
+            tr.replaceWith(start - 1, end, isFunction(fragment)
+                ? (_a = fragment(matchStr)) !== null && _a !== void 0 ? _a : Fragment.empty
+                : fragment !== null && fragment !== void 0 ? fragment : Fragment.empty).setSelection(new TextSelection(tr.doc.resolve(start + selectionOffset)));
+        }
+        return tr;
+    });
+}
+export function inlineNodeInputRule(regexp, fragment) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        var _a;
+        if (hasCodeMark(state, match, start, end))
+            return null;
+        const [matchStr] = match;
+        const { tr } = state;
+        if (matchStr) {
+            tr.replaceWith(start, end, (_a = fragment(matchStr)) !== null && _a !== void 0 ? _a : Fragment.empty).setSelection(new TextSelection(tr.doc.resolve(end)));
+        }
+        return tr;
+    });
+}

package/build/esm/utils/keymap.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare function withLogAction(action: string, command: Command): Command;

package/build/esm/utils/keymap.js

@@ -0,0 +1,9 @@
+import { logger } from '../logger';
+export function withLogAction(action, command) {
+    return (...args) => {
+        const res = command(...args);
+        if (res)
+            logger.action({ action, source: 'keymap' });
+        return res;
+    };
+}

package/build/esm/utils/marks.d.ts

@@ -0,0 +1,4 @@
+import type { Mark, MarkType, Node } from 'prosemirror-model';
+import type { EditorState } from 'prosemirror-state';
+export declare const findMark: (node: Node, markType: MarkType) => Mark | undefined;
+export declare function isMarkActive(state: EditorState, type: MarkType): boolean | Mark | undefined;

package/build/esm/utils/marks.js

@@ -0,0 +1,10 @@
+export const findMark = (node, markType) => {
+    return node.marks.find((mark) => mark.type.name === markType.name);
+};
+export function isMarkActive(state, type) {
+    const { from, $from, to, empty } = state.selection;
+    if (empty) {
+        return type.isInSet(state.storedMarks || $from.marks());
+    }
+    return state.doc.rangeHasMark(from, to, type);
+}

package/build/esm/utils/node-children.d.ts

@@ -0,0 +1,10 @@
+import { Node } from 'prosemirror-model';
+declare type ChildWithMeta = {
+    node: Node;
+    offset: number;
+    index: number;
+};
+export declare function getChildBy(parent: Node, f: (child: ChildWithMeta) => boolean): ChildWithMeta | null;
+export declare function getChildByNode(parent: Node, child: Node): ChildWithMeta | null;
+export declare function getChildByIndex(parent: Node, childIndex: number): ChildWithMeta | null;
+export {};

package/build/esm/utils/node-children.js

@@ -0,0 +1,16 @@
+export function getChildBy(parent, f) {
+    let result = null;
+    parent.forEach((node, offset, index) => {
+        const child = { node, offset, index };
+        if (f(child)) {
+            result = child;
+        }
+    });
+    return result;
+}
+export function getChildByNode(parent, child) {
+    return getChildBy(parent, ({ node }) => node === child);
+}
+export function getChildByIndex(parent, childIndex) {
+    return getChildBy(parent, ({ index }) => index === childIndex);
+}

package/build/esm/utils/nodes.d.ts

@@ -0,0 +1,15 @@
+import { Fragment, Node } from 'prosemirror-model';
+export declare function findFirstTextblockChild(parent: Node | Fragment): {
+    node: Node;
+    offset: number;
+} | null;
+export declare const isNodeEmpty: (node: Node) => boolean;
+export declare const isSelectableNode: (node: Node) => boolean;
+export declare function isCodeBlock(node: Node): boolean;
+export declare type NodeChild = {
+    node: Node;
+    offset: number;
+    index: number;
+};
+export declare function getChildrenOfNode(node: Node | Fragment): NodeChild[];
+export declare function getLastChildOfNode(node: Node | Fragment): NodeChild;

package/build/esm/utils/nodes.js

@@ -0,0 +1,45 @@
+import { Node } from 'prosemirror-model';
+import { findChildren } from 'prosemirror-utils';
+export function findFirstTextblockChild(parent) {
+    if (parent instanceof Node && (!parent.isBlock || parent.isAtom))
+        return null;
+    for (const child of getChildrenOfNode(parent)) {
+        if (child.node.isTextblock)
+            return child;
+        const nestedTextBlockChild = findFirstTextblockChild(child.node);
+        if (nestedTextBlockChild) {
+            return {
+                node: nestedTextBlockChild.node,
+                offset: child.offset + nestedTextBlockChild.offset,
+            };
+        }
+    }
+    return null;
+}
+export const isNodeEmpty = (node) => {
+    const emptyChildren = findChildren(node, (n) => (!n.isText && !n.isAtom && n.content.size === 0) || (n.isText && !n.textContent), true);
+    let descendantsCount = 0;
+    node.descendants(() => {
+        descendantsCount++;
+    });
+    return emptyChildren.length === descendantsCount;
+};
+export const isSelectableNode = (node) => {
+    if (node.type.spec.selectable === false)
+        return false;
+    if (node.type.isText && node.type.spec.selectable !== true)
+        return false;
+    return true;
+};
+export function isCodeBlock(node) {
+    return node.isTextblock && Boolean(node.type.spec.code);
+}
+export function getChildrenOfNode(node) {
+    const children = [];
+    node.forEach((node, offset, index) => children.push({ node, offset, index }));
+    return children;
+}
+export function getLastChildOfNode(node) {
+    const children = getChildrenOfNode(node);
+    return children[children.length - 1];
+}

package/build/esm/utils/placeholder.d.ts

@@ -0,0 +1,3 @@
+import type { Node, NodeSpec } from 'prosemirror-model';
+export declare type PlaceholderOptions = Record<string, NonNullable<NodeSpec['placeholder']>['content']>;
+export declare const getPlaceholderContent: (node: Node, parent?: Node | null) => string | null;

package/build/esm/utils/placeholder.js

@@ -0,0 +1,5 @@
+export const getPlaceholderContent = (node, parent) => {
+    var _a;
+    const content = ((_a = node.type.spec.placeholder) === null || _a === void 0 ? void 0 : _a.content) || '';
+    return typeof content === 'function' ? content(node, parent) : content;
+};

package/build/esm/utils/platform.d.ts

@@ -0,0 +1 @@
+export declare const isMac: () => boolean;